static void
gtk_alignment_init (GtkAlignment *alignment)
{
- GTK_WIDGET_SET_FLAGS (alignment, GTK_NO_WINDOW | GTK_BASIC);
+ GTK_WIDGET_SET_FLAGS (alignment, GTK_NO_WINDOW);
alignment->xalign = 0.5;
alignment->yalign = 0.5;
/* --- functions --- */
-void
+GtkArgInfo*
gtk_arg_type_new_static (GtkType base_class_type,
const gchar *arg_name,
guint class_n_args_offset,
guint *n_args_p;
gchar *p;
- g_return_if_fail (arg_name != NULL);
- g_return_if_fail (GTK_FUNDAMENTAL_TYPE (base_class_type) == GTK_TYPE_OBJECT);
- g_return_if_fail (class_n_args_offset != 0);
- g_return_if_fail (arg_info_hash_table != NULL);
- g_return_if_fail (arg_type > GTK_TYPE_NONE);
- g_return_if_fail (arg_id > 0);
- g_return_if_fail ((arg_flags & GTK_ARG_READWRITE) != 0);
- /* g_return_if_fail ((arg_flags & GTK_ARG_CHILD_ARG) == 0); */
+ g_return_val_if_fail (arg_name != NULL, NULL);
+ g_return_val_if_fail (GTK_FUNDAMENTAL_TYPE (base_class_type) == GTK_TYPE_OBJECT, NULL);
+ g_return_val_if_fail (class_n_args_offset != 0, NULL);
+ g_return_val_if_fail (arg_info_hash_table != NULL, NULL);
+ g_return_val_if_fail (arg_type > GTK_TYPE_NONE, NULL);
+ g_return_val_if_fail (arg_id > 0, NULL);
+ g_return_val_if_fail ((arg_flags & GTK_ARG_READWRITE) != 0, NULL);
+ /* g_return_val_if_fail ((arg_flags & GTK_ARG_CHILD_ARG) == 0, NULL); */
arg_flags &= GTK_ARG_MASK;
if (!arg_part || (arg_part[0] != ':') || (arg_part[1] != ':'))
{
g_warning ("gtk_arg_type_new(): invalid arg name: \"%s\"\n", arg_name);
- return;
+ return NULL;
}
class_offset = (guint) (arg_part - arg_name);
g_warning ("gtk_arg_type_new(): argument class in \"%s\" is not in the `%s' ancestry",
arg_name,
gtk_type_name (base_class_type));
- return;
+ return NULL;
}
p = gtk_type_class (class_type);
info->seq_id = *n_args_p;
g_hash_table_insert (arg_info_hash_table, info, info);
+
+ return info;
}
gchar*
/* Non-public methods */
-GtkArg* gtk_arg_new (GtkType arg_type);
-GtkArg* gtk_arg_copy (GtkArg *src_arg,
- GtkArg *dest_arg);
-void gtk_arg_free (GtkArg *arg,
- gboolean free_contents);
-gchar* gtk_args_collect (GtkType object_type,
- GHashTable *arg_info_hash_table,
- GSList **arg_list_p,
- GSList **info_list_p,
- const gchar *first_arg_name,
- va_list var_args);
-void gtk_args_collect_cleanup (GSList *arg_list,
- GSList *info_list);
-gchar* gtk_arg_get_info (GtkType object_type,
- GHashTable *arg_info_hash_table,
- const gchar *arg_name,
- GtkArgInfo **info_p);
-void gtk_arg_type_new_static (GtkType base_class_type,
- const gchar *arg_name,
- guint class_n_args_offset,
- GHashTable *arg_info_hash_table,
- GtkType arg_type,
- guint arg_flags,
- guint arg_id);
-GtkArg* gtk_args_query (GtkType class_type,
- GHashTable *arg_info_hash_table,
- guint32 **arg_flags,
- guint *n_args_p);
-gchar* gtk_arg_name_strip_type (const gchar *arg_name);
-gint gtk_arg_info_equal (gconstpointer arg_info_1,
- gconstpointer arg_info_2);
-guint gtk_arg_info_hash (gconstpointer arg_info);
+GtkArg* gtk_arg_new (GtkType arg_type);
+GtkArg* gtk_arg_copy (GtkArg *src_arg,
+ GtkArg *dest_arg);
+void gtk_arg_free (GtkArg *arg,
+ gboolean free_contents);
+gchar* gtk_args_collect (GtkType object_type,
+ GHashTable *arg_info_hash_table,
+ GSList **arg_list_p,
+ GSList **info_list_p,
+ const gchar *first_arg_name,
+ va_list var_args);
+void gtk_args_collect_cleanup (GSList *arg_list,
+ GSList *info_list);
+gchar* gtk_arg_get_info (GtkType object_type,
+ GHashTable *arg_info_hash_table,
+ const gchar *arg_name,
+ GtkArgInfo **info_p);
+GtkArgInfo* gtk_arg_type_new_static (GtkType base_class_type,
+ const gchar *arg_name,
+ guint class_n_args_offset,
+ GHashTable *arg_info_hash_table,
+ GtkType arg_type,
+ guint arg_flags,
+ guint arg_id);
+GtkArg* gtk_args_query (GtkType class_type,
+ GHashTable *arg_info_hash_table,
+ guint32 **arg_flags,
+ guint *n_args_p);
+gchar* gtk_arg_name_strip_type (const gchar *arg_name);
+gint gtk_arg_info_equal (gconstpointer arg_info_1,
+ gconstpointer arg_info_2);
+guint gtk_arg_info_hash (gconstpointer arg_info);
static void
gtk_box_init (GtkBox *box)
{
- GTK_WIDGET_SET_FLAGS (box, GTK_NO_WINDOW | GTK_BASIC);
+ GTK_WIDGET_SET_FLAGS (box, GTK_NO_WINDOW);
box->children = NULL;
box->spacing = 0;
#endif /* __cplusplus */
-#define GTK_TYPE_BOX (gtk_box_get_type ())
-#define GTK_BOX(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_BOX, GtkBox))
-#define GTK_BOX_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_BOX, GtkBoxClass))
-#define GTK_IS_BOX(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_BOX))
-#define GTK_IS_BOX_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_BOX))
+#define GTK_TYPE_BOX (gtk_box_get_type ())
+#define GTK_BOX(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_BOX, GtkBox))
+#define GTK_BOX_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_BOX, GtkBoxClass))
+#define GTK_IS_BOX(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_BOX))
+#define GTK_IS_BOX_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_BOX))
typedef struct _GtkBox GtkBox;
enum {
ARG_0,
- ARG_HADJUSTMENT,
- ARG_VADJUSTMENT
+ ARG_N_COLUMNS,
+ ARG_SHADOW_TYPE,
+ ARG_SELECTION_MODE,
+ ARG_ROW_HEIGHT
};
static void sync_selection (GtkCList * clist,
static void gtk_clist_finalize (GtkObject *object);
/* GtkWidget Methods */
+static void gtk_clist_scroll_adjustments (GtkCList *clist,
+ GtkAdjustment *hadjustment,
+ GtkAdjustment *vadjustment);
static void gtk_clist_realize (GtkWidget *widget);
static void gtk_clist_unrealize (GtkWidget *widget);
static void gtk_clist_map (GtkWidget *widget);
parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
- gtk_object_add_arg_type ("GtkCList::hadjustment",
- GTK_TYPE_ADJUSTMENT,
+ gtk_object_add_arg_type ("GtkCList::n_columns",
+ GTK_TYPE_UINT,
+ GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT_ONLY,
+ ARG_N_COLUMNS);
+ gtk_object_add_arg_type ("GtkCList::shadow_type",
+ GTK_TYPE_SHADOW_TYPE,
GTK_ARG_READWRITE,
- ARG_HADJUSTMENT);
- gtk_object_add_arg_type ("GtkCList::vadjustment",
- GTK_TYPE_ADJUSTMENT,
+ ARG_SHADOW_TYPE);
+ gtk_object_add_arg_type ("GtkCList::selection_mode",
+ GTK_TYPE_SELECTION_MODE,
GTK_ARG_READWRITE,
- ARG_VADJUSTMENT);
+ ARG_SELECTION_MODE);
+ gtk_object_add_arg_type ("GtkCList::row_height",
+ GTK_TYPE_UINT,
+ GTK_ARG_READWRITE,
+ ARG_ROW_HEIGHT);
+
+ object_class->set_arg = gtk_clist_set_arg;
+ object_class->get_arg = gtk_clist_get_arg;
+ object_class->destroy = gtk_clist_destroy;
+ object_class->finalize = gtk_clist_finalize;
+
+
+ widget_class->scroll_adjustments_signal =
+ gtk_signal_new ("scroll_adjustments",
+ GTK_RUN_LAST,
+ object_class->type,
+ GTK_SIGNAL_OFFSET (GtkCListClass, scroll_adjustments),
+ gtk_marshal_NONE__POINTER_POINTER,
+ GTK_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
clist_signals[SELECT_ROW] =
gtk_signal_new ("select_row",
GTK_SIGNAL_OFFSET (GtkCListClass, abort_column_resize),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
-
-
gtk_object_class_add_signals (object_class, clist_signals, LAST_SIGNAL);
- object_class->set_arg = gtk_clist_set_arg;
- object_class->get_arg = gtk_clist_get_arg;
- object_class->destroy = gtk_clist_destroy;
- object_class->finalize = gtk_clist_finalize;
-
widget_class->realize = gtk_clist_realize;
widget_class->unrealize = gtk_clist_unrealize;
widget_class->map = gtk_clist_map;
container_class->focus = gtk_clist_focus;
container_class->set_focus_child = gtk_clist_set_focus_child;
+ klass->scroll_adjustments = gtk_clist_scroll_adjustments;
klass->select_row = real_select_row;
klass->unselect_row = real_unselect_row;
klass->undo_selection = real_undo_selection;
guint arg_id)
{
GtkCList *clist;
- GtkAdjustment *adjustment;
clist = GTK_CLIST (object);
switch (arg_id)
{
- case ARG_HADJUSTMENT:
- adjustment = GTK_VALUE_POINTER (*arg);
- gtk_clist_set_hadjustment (clist, adjustment);
+ case ARG_N_COLUMNS: /* construct-only arg, only set when !GTK_CONSTRUCTED */
+ gtk_clist_construct (clist, MAX (1, GTK_VALUE_UINT (*arg)), NULL);
+ break;
+ case ARG_SHADOW_TYPE:
+ gtk_clist_set_shadow_type (clist, GTK_VALUE_ENUM (*arg));
break;
- case ARG_VADJUSTMENT:
- adjustment = GTK_VALUE_POINTER (*arg);
- gtk_clist_set_vadjustment (clist, adjustment);
+ case ARG_SELECTION_MODE:
+ gtk_clist_set_selection_mode (clist, GTK_VALUE_ENUM (*arg));
+ break;
+ case ARG_ROW_HEIGHT:
+ gtk_clist_set_row_height (clist, GTK_VALUE_UINT (*arg));
break;
default:
break;
switch (arg_id)
{
- case ARG_HADJUSTMENT:
- GTK_VALUE_POINTER (*arg) = clist->hadjustment;
+ case ARG_N_COLUMNS:
+ GTK_VALUE_UINT (*arg) = clist->columns;
+ break;
+ case ARG_SHADOW_TYPE:
+ GTK_VALUE_ENUM (*arg) = clist->shadow_type;
+ break;
+ case ARG_SELECTION_MODE:
+ GTK_VALUE_ENUM (*arg) = clist->selection_mode;
break;
- case ARG_VADJUSTMENT:
- GTK_VALUE_POINTER (*arg) = clist->vadjustment;
+ case ARG_ROW_HEIGHT:
+ GTK_VALUE_UINT (*arg) = GTK_CLIST_ROW_HEIGHT_SET (clist) ? clist->row_height : 0;
break;
default:
arg->type = GTK_TYPE_INVALID;
gint columns,
gchar *titles[])
{
- int i;
-
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
- g_return_if_fail (GTK_CLIST_CONSTRUCTED (clist) == FALSE);
+ g_return_if_fail (columns > 0);
+ g_return_if_fail (GTK_OBJECT_CONSTRUCTED (clist) == FALSE);
- GTK_CLIST_SET_FLAG (clist, CLIST_CONSTRUCTED);
+ /* mark the object as constructed */
+ gtk_object_constructed (GTK_OBJECT (clist));
/* initalize memory chunks, if this has not been done by any
* possibly derived widget
if (titles)
{
+ guint i;
+
GTK_CLIST_SET_FLAG (clist, CLIST_SHOW_TITLES);
for (i = 0; i < columns; i++)
gtk_clist_set_column_title (clist, i, titles[i]);
* gtk_clist_set_shadow_type
* gtk_clist_set_border *** deprecated function ***
* gtk_clist_set_selection_mode
- * gtk_clist_set_policy
* gtk_clist_freeze
* gtk_clist_thaw
*/
-GtkWidget *
+GtkWidget*
gtk_clist_new (gint columns)
{
return gtk_clist_new_with_titles (columns, NULL);
}
-GtkWidget *
+GtkWidget*
gtk_clist_new_with_titles (gint columns,
gchar *titles[])
{
widget = gtk_type_new (GTK_TYPE_CLIST);
gtk_clist_construct (GTK_CLIST (widget), columns, titles);
+
return widget;
}
return clist->vadjustment;
}
+static void
+gtk_clist_scroll_adjustments (GtkCList *clist,
+ GtkAdjustment *hadjustment,
+ GtkAdjustment *vadjustment)
+{
+ if (clist->hadjustment != hadjustment)
+ gtk_clist_set_hadjustment (clist, hadjustment);
+ if (clist->vadjustment != vadjustment)
+ gtk_clist_set_vadjustment (clist, vadjustment);
+}
+
void
gtk_clist_set_shadow_type (GtkCList *clist,
GtkShadowType type)
gtk_clist_set_border (GtkCList *clist,
GtkShadowType border)
{
+ g_message ("gtk_clist_set_border() is deprecated");
+
gtk_clist_set_shadow_type (clist, border);
}
}
}
-void
-gtk_clist_set_policy (GtkCList *clist,
- GtkPolicyType vscrollbar_policy,
- GtkPolicyType hscrollbar_policy)
-{
- g_return_if_fail (clist != NULL);
- g_return_if_fail (GTK_IS_CLIST (clist));
-}
-
void
gtk_clist_freeze (GtkCList *clist)
{
break;
}
+ gtk_widget_push_composite_child ();
label = gtk_label_new (clist->column[column].title);
+ gtk_widget_pop_composite_child ();
gtk_container_add (GTK_CONTAINER (alignment), label);
gtk_container_add (GTK_CONTAINER (clist->column[column].button), alignment);
gtk_widget_show (label);
{
GtkWidget *button;
+ gtk_widget_push_composite_child ();
button = clist->column[column].button = gtk_button_new ();
+ gtk_widget_pop_composite_child ();
if (GTK_WIDGET_REALIZED (clist) && clist->title_window)
gtk_widget_set_parent_window (clist->column[column].button,
void
gtk_clist_set_row_height (GtkCList *clist,
- gint height)
+ guint height)
{
+ GtkWidget *widget;
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
+ widget = GTK_WIDGET (clist);
+
if (height > 0)
- clist->row_height = height;
+ {
+ clist->row_height = height;
+ GTK_CLIST_SET_FLAG (clist, CLIST_ROW_HEIGHT_SET);
+ }
else
- return;
+ {
+ GTK_CLIST_UNSET_FLAG (clist, CLIST_ROW_HEIGHT_SET);
+ clist->row_height = 0;
+ }
- GTK_CLIST_SET_FLAG (clist, CLIST_ROW_HEIGHT_SET);
-
if (GTK_WIDGET_REALIZED (clist))
{
- GdkFont *font;
-
- font = GTK_WIDGET (clist)->style->font;
- clist->row_center_offset = (((height + font->ascent - font->descent - 1)
- / 2) + 1.5);
+ if (!GTK_CLIST_ROW_HEIGHT_SET (clist))
+ {
+ clist->row_height = (widget->style->font->ascent +
+ widget->style->font->descent + 1);
+ clist->row_center_offset = widget->style->font->ascent + 1.5;
+ }
+ else
+ clist->row_center_offset = 1.5 + (clist->row_height +
+ widget->style->font->ascent -
+ widget->style->font->descent - 1) / 2;
}
if (!GTK_CLIST_FROZEN (clist))
/* unref adjustments */
if (clist->hadjustment)
{
+ gtk_signal_disconnect_by_data (GTK_OBJECT (clist->hadjustment), clist);
gtk_object_unref (GTK_OBJECT (clist->hadjustment));
clist->hadjustment = NULL;
}
if (clist->vadjustment)
{
+ gtk_signal_disconnect_by_data (GTK_OBJECT (clist->vadjustment), clist);
gtk_object_unref (GTK_OBJECT (clist->vadjustment));
clist->vadjustment = NULL;
}
GTK_CLIST_DRAG_SELECTION = 1 << 2,
GTK_CLIST_ROW_HEIGHT_SET = 1 << 3,
GTK_CLIST_SHOW_TITLES = 1 << 4,
- GTK_CLIST_CONSTRUCTED = 1 << 5,
- GTK_CLIST_CHILD_HAS_FOCUS = 1 << 6,
- GTK_CLIST_ADD_MODE = 1 << 7,
- GTK_CLIST_AUTO_SORT = 1 << 8,
- GTK_CLIST_AUTO_RESIZE_BLOCKED = 1 << 9
+ GTK_CLIST_CHILD_HAS_FOCUS = 1 << 5,
+ GTK_CLIST_ADD_MODE = 1 << 6,
+ GTK_CLIST_AUTO_SORT = 1 << 7,
+ GTK_CLIST_AUTO_RESIZE_BLOCKED = 1 << 8
};
/* cell types */
#define GTK_CLIST_IN_DRAG(clist) (GTK_CLIST_FLAGS (clist) & GTK_CLIST_IN_DRAG)
#define GTK_CLIST_ROW_HEIGHT_SET(clist) (GTK_CLIST_FLAGS (clist) & GTK_CLIST_ROW_HEIGHT_SET)
#define GTK_CLIST_SHOW_TITLES(clist) (GTK_CLIST_FLAGS (clist) & GTK_CLIST_SHOW_TITLES)
-#define GTK_CLIST_CONSTRUCTED(clist) (GTK_CLIST_FLAGS (clist) & GTK_CLIST_CONSTRUCTED)
#define GTK_CLIST_CHILD_HAS_FOCUS(clist) (GTK_CLIST_FLAGS (clist) & GTK_CLIST_CHILD_HAS_FOCUS)
#define GTK_CLIST_DRAG_SELECTION(clist) (GTK_CLIST_FLAGS (clist) & GTK_CLIST_DRAG_SELECTION)
#define GTK_CLIST_ADD_MODE(clist) (GTK_CLIST_FLAGS (clist) & GTK_CLIST_ADD_MODE)
{
GtkContainerClass parent_class;
+ void (*scroll_adjustments) (GtkCList *clist,
+ GtkAdjustment *hadjustment,
+ GtkAdjustment *vadjustment);
void (*select_row) (GtkCList *clist,
gint row,
gint column,
GtkType gtk_clist_get_type (void);
-/* constructers useful for gtk-- wrappers */
+/* constructors useful for gtk-- wrappers */
void gtk_clist_construct (GtkCList *clist,
gint columns,
gchar *titles[]);
gint column,
gint max_width);
-/* change the height of the rows, the default is the hight
- * of the current font
+/* change the height of the rows, the default (height=0) is
+ * the hight of the current font.
*/
void gtk_clist_set_row_height (GtkCList *clist,
- gint height);
+ guint height);
/* scroll the viewing area of the list to the given column and row;
* row_align and col_align are between 0-1 representing the location the
void gtk_clist_set_border (GtkCList *clist,
GtkShadowType border);
-/* Completely non-functional */
-void gtk_clist_set_policy (GtkCList *clist,
- GtkPolicyType vscrollbar_policy,
- GtkPolicyType hscrollbar_policy);
#ifdef __cplusplus
}
#endif /* __cplusplus */
2 * popwin->child->style->klass->xthickness -
2 * GTK_CONTAINER (popwin->child)->border_width -
2 * GTK_CONTAINER (combo->popup)->border_width -
- 2 * GTK_CONTAINER (popup->viewport)->border_width -
- 2 * popup->viewport->style->klass->xthickness);
+ 2 * GTK_CONTAINER (popup->child)->border_width -
+ 2 * popup->child->style->klass->xthickness);
work_height = (2 * popwin->child->style->klass->ythickness +
2 * GTK_CONTAINER (popwin->child)->border_width +
2 * GTK_CONTAINER (combo->popup)->border_width +
- 2 * GTK_CONTAINER (popup->viewport)->border_width +
- 2 * popup->viewport->style->klass->xthickness);
+ 2 * GTK_CONTAINER (popup->child)->border_width +
+ 2 * popup->child->style->klass->xthickness);
do
{
gtk_widget_set_events (combo->list, GDK_ENTER_NOTIFY_MASK);
gtk_list_set_selection_mode(GTK_LIST(combo->list), GTK_SELECTION_BROWSE);
- gtk_container_add (GTK_CONTAINER (combo->popup), combo->list);
+ gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (combo->popup), combo->list);
gtk_container_set_focus_vadjustment (GTK_CONTAINER (combo->list),
gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (combo->popup)));
gtk_container_set_focus_hadjustment (GTK_CONTAINER (combo->list),
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (widget->parent == NULL);
+ g_return_if_fail (GTK_OBJECT_CONSTRUCTED (container) == TRUE);
gtk_widget_ref (GTK_WIDGET (container));
gtk_widget_ref (widget);
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (widget->parent == NULL);
+ g_return_if_fail (GTK_OBJECT_CONSTRUCTED (container) == TRUE);
gtk_widget_ref (GTK_WIDGET (container));
gtk_widget_ref (widget);
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (widget->parent == NULL);
+ g_return_if_fail (GTK_OBJECT_CONSTRUCTED (container) == TRUE);
gtk_signal_emit (GTK_OBJECT (container), container_signals[ADD], widget);
}
gtk_signal_emit (GTK_OBJECT (container), container_signals[REMOVE], widget);
}
-void
-gtk_container_disable_resize (GtkContainer *container)
-{
- g_warning ("gtk_container_disable_resize does nothing!");
-}
-
-void
-gtk_container_enable_resize (GtkContainer *container)
-{
- g_warning ("gtk_container_enable_resize does nothing!");
-}
-
void
gtk_container_block_resize (GtkContainer *container)
{
g_return_if_fail (container != NULL);
g_return_if_fail (GTK_IS_CONTAINER (container));
+ g_message ("gtk_container_block_resize() is deprecated");
}
void
g_return_if_fail (container != NULL);
g_return_if_fail (GTK_IS_CONTAINER (container));
+ g_message ("gtk_container_unblock_resize() is deprecated");
}
void
gint
gtk_container_need_resize (GtkContainer *container)
{
+ g_message ("gtk_container_need_resize() is deprecated");
+
gtk_container_check_resize (container);
return FALSE;
}
/* Deprecated methods */
-/* Completely non-functional */
-void gtk_container_disable_resize (GtkContainer *container);
-void gtk_container_enable_resize (GtkContainer *container);
-
/* Use gtk_container_set_resize_mode() instead */
void gtk_container_block_resize (GtkContainer *container);
void gtk_container_unblock_resize (GtkContainer *container);
#define GTK_CLIST_CLASS_FW(_widget_) GTK_CLIST_CLASS (GTK_OBJECT (_widget_)->klass)
+enum {
+ ARG_0,
+ ARG_N_COLUMNS,
+ ARG_TREE_COLUMN,
+ ARG_INDENT,
+ ARG_SPACING,
+ ARG_SHOW_STUB,
+ ARG_REORDERABLE,
+ ARG_USE_DRAG_ICONS,
+ ARG_LINE_STYLE,
+ ARG_EXPANDER_STYLE
+};
+
static void gtk_ctree_class_init (GtkCTreeClass *klass);
static void gtk_ctree_init (GtkCTree *ctree);
+static void gtk_ctree_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
+static void gtk_ctree_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
static void gtk_ctree_realize (GtkWidget *widget);
static void gtk_ctree_unrealize (GtkWidget *widget);
static gint gtk_ctree_button_press (GtkWidget *widget,
parent_class = gtk_type_class (GTK_TYPE_CLIST);
container_class = gtk_type_class (GTK_TYPE_CONTAINER);
+ gtk_object_add_arg_type ("GtkCTree::n_columns",
+ GTK_TYPE_UINT,
+ GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT_ONLY,
+ ARG_N_COLUMNS);
+ gtk_object_add_arg_type ("GtkCTree::tree_column",
+ GTK_TYPE_UINT,
+ GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT_ONLY,
+ ARG_TREE_COLUMN);
+ gtk_object_add_arg_type ("GtkCTree::indent",
+ GTK_TYPE_UINT,
+ GTK_ARG_READWRITE,
+ ARG_INDENT);
+ gtk_object_add_arg_type ("GtkCTree::spacing",
+ GTK_TYPE_UINT,
+ GTK_ARG_READWRITE,
+ ARG_SPACING);
+ gtk_object_add_arg_type ("GtkCTree::show_stub",
+ GTK_TYPE_BOOL,
+ GTK_ARG_READWRITE,
+ ARG_SHOW_STUB);
+ gtk_object_add_arg_type ("GtkCTree::reorderable",
+ GTK_TYPE_BOOL,
+ GTK_ARG_READWRITE,
+ ARG_REORDERABLE);
+ gtk_object_add_arg_type ("GtkCTree::use_drag_icons",
+ GTK_TYPE_BOOL,
+ GTK_ARG_READWRITE,
+ ARG_USE_DRAG_ICONS);
+ gtk_object_add_arg_type ("GtkCTree::line_style",
+ GTK_TYPE_C_TREE_LINE_STYLE,
+ GTK_ARG_READWRITE,
+ ARG_LINE_STYLE);
+ gtk_object_add_arg_type ("GtkCTree::expander_style",
+ GTK_TYPE_C_TREE_EXPANDER_STYLE,
+ GTK_ARG_READWRITE,
+ ARG_EXPANDER_STYLE);
+ object_class->set_arg = gtk_ctree_set_arg;
+ object_class->get_arg = gtk_ctree_get_arg;
+
ctree_signals[TREE_SELECT_ROW] =
gtk_signal_new ("tree_select_row",
GTK_RUN_FIRST,
change_focus_row_expansion),
gtk_marshal_NONE__ENUM,
GTK_TYPE_NONE, 1, GTK_TYPE_C_TREE_EXPANSION_TYPE);
-
gtk_object_class_add_signals (object_class, ctree_signals, LAST_SIGNAL);
widget_class->realize = gtk_ctree_realize;
}
+static void
+gtk_ctree_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkCTree *ctree;
+
+ ctree = GTK_CTREE (object);
+
+ switch (arg_id)
+ {
+ case ARG_N_COLUMNS: /* construct-only arg, only set when !GTK_CONSTRUCTED */
+ if (ctree->tree_column)
+ gtk_ctree_construct (ctree,
+ MAX (1, GTK_VALUE_UINT (*arg)),
+ ctree->tree_column, NULL);
+ else
+ GTK_CLIST (ctree)->columns = MAX (1, GTK_VALUE_UINT (*arg));
+ break;
+ case ARG_TREE_COLUMN: /* construct-only arg, only set when !GTK_CONSTRUCTED */
+ if (GTK_CLIST (ctree)->columns)
+ gtk_ctree_construct (ctree,
+ GTK_CLIST (ctree)->columns,
+ MAX (1, GTK_VALUE_UINT (*arg)),
+ NULL);
+ else
+ ctree->tree_column = MAX (1, GTK_VALUE_UINT (*arg));
+ break;
+ case ARG_INDENT:
+ gtk_ctree_set_indent (ctree, GTK_VALUE_UINT (*arg));
+ break;
+ case ARG_SPACING:
+ gtk_ctree_set_spacing (ctree, GTK_VALUE_UINT (*arg));
+ break;
+ case ARG_SHOW_STUB:
+ gtk_ctree_set_show_stub (ctree, GTK_VALUE_BOOL (*arg));
+ break;
+ case ARG_REORDERABLE:
+ gtk_ctree_set_reorderable (ctree, GTK_VALUE_BOOL (*arg));
+ break;
+ case ARG_USE_DRAG_ICONS:
+ gtk_ctree_set_use_drag_icons (ctree, GTK_VALUE_BOOL (*arg));
+ break;
+ case ARG_LINE_STYLE:
+ gtk_ctree_set_line_style (ctree, GTK_VALUE_ENUM (*arg));
+ break;
+ case ARG_EXPANDER_STYLE:
+ gtk_ctree_set_expander_style (ctree, GTK_VALUE_ENUM (*arg));
+ break;
+ default:
+ break;
+ }
+}
+
+static void
+gtk_ctree_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkCTree *ctree;
+
+ ctree = GTK_CTREE (object);
+
+ switch (arg_id)
+ {
+ case ARG_N_COLUMNS:
+ GTK_VALUE_UINT (*arg) = GTK_CLIST (ctree)->columns;
+ break;
+ case ARG_TREE_COLUMN:
+ GTK_VALUE_UINT (*arg) = ctree->tree_column;
+ break;
+ case ARG_INDENT:
+ GTK_VALUE_UINT (*arg) = ctree->tree_indent;
+ break;
+ case ARG_SPACING:
+ GTK_VALUE_UINT (*arg) = ctree->tree_spacing;
+ break;
+ case ARG_SHOW_STUB:
+ GTK_VALUE_BOOL (*arg) = ctree->show_stub;
+ break;
+ case ARG_REORDERABLE:
+ GTK_VALUE_BOOL (*arg) = ctree->reorderable;
+ break;
+ case ARG_USE_DRAG_ICONS:
+ GTK_VALUE_BOOL (*arg) = ctree->use_icons;
+ break;
+ case ARG_LINE_STYLE:
+ GTK_VALUE_ENUM (*arg) = ctree->line_style;
+ break;
+ case ARG_EXPANDER_STYLE:
+ GTK_VALUE_ENUM (*arg) = ctree->expander_style;
+ break;
+ default:
+ arg->type = GTK_TYPE_INVALID;
+ break;
+ }
+}
+
static void
gtk_ctree_init (GtkCTree *ctree)
{
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
- g_return_if_fail (GTK_CLIST_CONSTRUCTED (ctree) == FALSE);
+ g_return_if_fail (GTK_OBJECT_CONSTRUCTED (ctree) == FALSE);
clist = GTK_CLIST (ctree);
widget = gtk_type_new (GTK_TYPE_CTREE);
gtk_ctree_construct (GTK_CTREE (widget), columns, tree_column, titles);
+
return widget;
}
}
void
-gtk_ctree_show_stub (GtkCTree *ctree,
+gtk_ctree_show_stub (GtkCTree *ctree,
gboolean show_stub)
+{
+ g_message ("gtk_ctree_show_stub() is deprecated");
+ gtk_ctree_set_show_stub (ctree, show_stub);
+}
+
+void
+gtk_ctree_set_show_stub (GtkCTree *ctree,
+ gboolean show_stub)
{
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
gint indent);
void gtk_ctree_set_spacing (GtkCTree *ctree,
gint spacing);
-void gtk_ctree_show_stub (GtkCTree *ctree,
+void gtk_ctree_set_show_stub (GtkCTree *ctree,
gboolean show_stub);
void gtk_ctree_set_reorderable (GtkCTree *ctree,
gboolean reorderable);
GtkCTreeNode *node);
void gtk_ctree_sort_recursive (GtkCTree *ctree,
GtkCTreeNode *node);
+
+
+/* deprecated*/
+void gtk_ctree_show_stub (GtkCTree *ctree,
+ gboolean show_stub);
+
+
+
#ifdef __cplusplus
}
#endif /* __cplusplus */
static void
gtk_drawing_area_init (GtkDrawingArea *darea)
{
- GTK_WIDGET_SET_FLAGS (darea, GTK_BASIC);
-
darea->draw_data = NULL;
}
gtk_event_box_init (GtkEventBox *event_box)
{
GTK_WIDGET_UNSET_FLAGS (event_box, GTK_NO_WINDOW);
- GTK_WIDGET_SET_FLAGS (event_box, GTK_BASIC);
}
GtkWidget*
gtk_fixed_init (GtkFixed *fixed)
{
GTK_WIDGET_UNSET_FLAGS (fixed, GTK_NO_WINDOW);
- GTK_WIDGET_SET_FLAGS (fixed, GTK_BASIC);
fixed->children = NULL;
}
static void
gtk_frame_init (GtkFrame *frame)
{
- GTK_WIDGET_SET_FLAGS (frame, GTK_BASIC);
-
frame->label = NULL;
frame->shadow_type = GTK_SHADOW_ETCHED_IN;
frame->label_width = 0;
gtk_handle_box_init (GtkHandleBox *handle_box)
{
GTK_WIDGET_UNSET_FLAGS (handle_box, GTK_NO_WINDOW);
- GTK_WIDGET_SET_FLAGS (handle_box, GTK_BASIC); /* FIXME: are we really a basic widget? */
handle_box->bin_window = NULL;
handle_box->float_window = NULL;
#endif /* __cplusplus */
-#define GTK_TYPE_HBOX (gtk_hbox_get_type ())
-#define GTK_HBOX(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_HBOX, GtkHBox))
-#define GTK_HBOX_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_HBOX, GtkHBoxClass))
-#define GTK_IS_HBOX(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_HBOX))
-#define GTK_IS_HBOX_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_HBOX))
+#define GTK_TYPE_HBOX (gtk_hbox_get_type ())
+#define GTK_HBOX(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_HBOX, GtkHBox))
+#define GTK_HBOX_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_HBOX, GtkHBoxClass))
+#define GTK_IS_HBOX(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_HBOX))
+#define GTK_IS_HBOX_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_HBOX))
typedef struct _GtkHBox GtkHBox;
#define SCALE_CLASS(w) GTK_SCALE_CLASS (GTK_OBJECT (w)->klass)
#define RANGE_CLASS(w) GTK_RANGE_CLASS (GTK_OBJECT (w)->klass)
+enum {
+ ARG_0,
+ ARG_ADJUSTMENT,
+};
static void gtk_hscale_class_init (GtkHScaleClass *klass);
static void gtk_hscale_init (GtkHScale *hscale);
+static void gtk_hscale_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
+static void gtk_hscale_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
static void gtk_hscale_realize (GtkWidget *widget);
static void gtk_hscale_size_request (GtkWidget *widget,
- GtkRequisition *requisition);
+ GtkRequisition *requisition);
static void gtk_hscale_size_allocate (GtkWidget *widget,
- GtkAllocation *allocation);
+ GtkAllocation *allocation);
static void gtk_hscale_pos_trough (GtkHScale *hscale,
- gint *x,
- gint *y,
- gint *w,
- gint *h);
+ gint *x,
+ gint *y,
+ gint *w,
+ gint *h);
static void gtk_hscale_pos_background (GtkHScale *hscale,
- gint *x,
- gint *y,
- gint *w,
- gint *h);
+ gint *x,
+ gint *y,
+ gint *w,
+ gint *h);
static void gtk_hscale_draw_slider (GtkRange *range);
static void gtk_hscale_draw_value (GtkScale *scale);
static void gtk_hscale_draw (GtkWidget *widget,
- GdkRectangle *area);
+ GdkRectangle *area);
static gint gtk_hscale_trough_keys (GtkRange *range,
- GdkEventKey *key,
- GtkScrollType *scroll,
- GtkTroughType *pos);
+ GdkEventKey *key,
+ GtkScrollType *scroll,
+ GtkTroughType *pos);
static void gtk_hscale_clear_background (GtkRange *range);
-guint
+GtkType
gtk_hscale_get_type (void)
{
- static guint hscale_type = 0;
-
+ static GtkType hscale_type = 0;
+
if (!hscale_type)
{
GtkTypeInfo hscale_info =
{
- "GtkHScale",
- sizeof (GtkHScale),
- sizeof (GtkHScaleClass),
- (GtkClassInitFunc) gtk_hscale_class_init,
- (GtkObjectInitFunc) gtk_hscale_init,
- /* reserved_1 */ NULL,
+ "GtkHScale",
+ sizeof (GtkHScale),
+ sizeof (GtkHScaleClass),
+ (GtkClassInitFunc) gtk_hscale_class_init,
+ (GtkObjectInitFunc) gtk_hscale_init,
+ /* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
};
-
- hscale_type = gtk_type_unique (gtk_scale_get_type (), &hscale_info);
+
+ hscale_type = gtk_type_unique (GTK_TYPE_SCALE, &hscale_info);
}
-
+
return hscale_type;
}
static void
gtk_hscale_class_init (GtkHScaleClass *class)
{
+ GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
GtkRangeClass *range_class;
GtkScaleClass *scale_class;
-
+
+ object_class = (GtkObjectClass*) class;
widget_class = (GtkWidgetClass*) class;
range_class = (GtkRangeClass*) class;
scale_class = (GtkScaleClass*) class;
-
+
+ gtk_object_add_arg_type ("GtkHScale::adjustment",
+ GTK_TYPE_ADJUSTMENT,
+ GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
+ ARG_ADJUSTMENT);
+
+ object_class->set_arg = gtk_hscale_set_arg;
+ object_class->get_arg = gtk_hscale_get_arg;
+
widget_class->realize = gtk_hscale_realize;
widget_class->size_request = gtk_hscale_size_request;
widget_class->size_allocate = gtk_hscale_size_allocate;
widget_class->draw = gtk_hscale_draw;
-
+
range_class->slider_update = gtk_range_default_hslider_update;
range_class->trough_click = gtk_range_default_htrough_click;
range_class->motion = gtk_range_default_hmotion;
range_class->draw_slider = gtk_hscale_draw_slider;
range_class->trough_keys = gtk_hscale_trough_keys;
range_class->clear_background = gtk_hscale_clear_background;
-
+
scale_class->draw_value = gtk_hscale_draw_value;
}
+static void
+gtk_hscale_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkHScale *hscale;
+
+ hscale = GTK_HSCALE (object);
+
+ switch (arg_id)
+ {
+ case ARG_ADJUSTMENT:
+ gtk_range_set_adjustment (GTK_RANGE (hscale), GTK_VALUE_POINTER (*arg));
+ break;
+ default:
+ break;
+ }
+}
+
+static void
+gtk_hscale_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkHScale *hscale;
+
+ hscale = GTK_HSCALE (object);
+
+ switch (arg_id)
+ {
+ case ARG_ADJUSTMENT:
+ GTK_VALUE_POINTER (*arg) = GTK_RANGE (hscale);
+ break;
+ default:
+ arg->type = GTK_TYPE_INVALID;
+ break;
+ }
+}
+
static void
gtk_hscale_init (GtkHScale *hscale)
{
GtkWidget*
gtk_hscale_new (GtkAdjustment *adjustment)
{
- GtkHScale *hscale;
-
- hscale = gtk_type_new (gtk_hscale_get_type ());
-
- if (!adjustment)
- adjustment = (GtkAdjustment*) gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
-
- gtk_range_set_adjustment (GTK_RANGE (hscale), adjustment);
+ GtkWidget *hscale;
+
+ hscale = gtk_widget_new (GTK_TYPE_HSCALE,
+ "adjustment", adjustment,
+ NULL);
- return GTK_WIDGET (hscale);
+ return hscale;
}
GdkWindowAttr attributes;
gint attributes_mask;
gint x, y, w, h;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_HSCALE (widget));
-
+
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
range = GTK_RANGE (widget);
-
+
widget->window = gtk_widget_get_parent_window (widget);
gdk_window_ref (widget->window);
-
+
gtk_hscale_pos_trough (GTK_HSCALE (widget), &x, &y, &w, &h);
+
attributes.x = x + widget->allocation.x;
attributes.y = y + widget->allocation.y;
attributes.width = w;
attributes.window_type = GDK_WINDOW_CHILD;
attributes.event_mask = gtk_widget_get_events (widget) |
- (GDK_EXPOSURE_MASK |
- GDK_BUTTON_PRESS_MASK |
- GDK_BUTTON_RELEASE_MASK |
- GDK_ENTER_NOTIFY_MASK |
- GDK_LEAVE_NOTIFY_MASK);
+ (GDK_EXPOSURE_MASK |
+ GDK_BUTTON_PRESS_MASK |
+ GDK_BUTTON_RELEASE_MASK |
+ GDK_ENTER_NOTIFY_MASK |
+ GDK_LEAVE_NOTIFY_MASK);
attributes.visual = gtk_widget_get_visual (widget);
attributes.colormap = gtk_widget_get_colormap (widget);
-
+
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
-
+
range->trough = gdk_window_new (widget->window, &attributes, attributes_mask);
-
+
attributes.width = SCALE_CLASS (range)->slider_length;
attributes.height = RANGE_CLASS (range)->slider_width;
attributes.event_mask |= (GDK_BUTTON_MOTION_MASK |
- GDK_POINTER_MOTION_HINT_MASK);
-
+ GDK_POINTER_MOTION_HINT_MASK);
+
range->slider = gdk_window_new (range->trough, &attributes, attributes_mask);
-
+
widget->style = gtk_style_attach (widget->style, widget->window);
-
+
gdk_window_set_user_data (range->trough, widget);
gdk_window_set_user_data (range->slider, widget);
-
+
gtk_style_set_background (widget->style, range->trough, GTK_STATE_ACTIVE);
gtk_style_set_background (widget->style, range->slider, GTK_STATE_NORMAL);
-
+
gtk_range_slider_update (GTK_RANGE (widget));
-
+
gdk_window_show (range->slider);
}
static void
gtk_hscale_draw (GtkWidget *widget,
- GdkRectangle *area)
+ GdkRectangle *area)
{
GtkRange *range;
GdkRectangle tmp_area;
GdkRectangle child_area;
gint x, y, width, height;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_RANGE (widget));
g_return_if_fail (area != NULL);
-
+
if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_MAPPED (widget))
{
range = GTK_RANGE (widget);
-
+
gtk_hscale_pos_background (GTK_HSCALE (widget), &x, &y, &width, &height);
-
+
tmp_area.x = x;
tmp_area.y = y;
tmp_area.width = width;
tmp_area.height = height;
-
+
if (gdk_rectangle_intersect (area, &tmp_area, &child_area))
- gtk_range_draw_background (range);
-
+ gtk_range_draw_background (range);
+
gtk_hscale_pos_trough (GTK_HSCALE (widget), &x, &y, &width, &height);
-
+
tmp_area.x = x;
tmp_area.y = y;
tmp_area.width = width;
tmp_area.height = height;
-
+
if (gdk_rectangle_intersect (area, &tmp_area, &child_area))
- {
- gtk_range_draw_trough (range);
- gtk_range_draw_slider (range);
- gtk_range_draw_step_forw (range);
- gtk_range_draw_step_back (range);
- }
+ {
+ gtk_range_draw_trough (range);
+ gtk_range_draw_slider (range);
+ gtk_range_draw_step_forw (range);
+ gtk_range_draw_step_back (range);
+ }
}
}
{
GtkWidget *widget;
gint x, y, width, height;
-
+
g_return_if_fail (range != NULL);
-
+
widget = GTK_WIDGET (range);
gtk_hscale_pos_background (GTK_HSCALE (range), &x, &y, &width, &height);
-
+
gtk_widget_queue_clear_area (GTK_WIDGET (range),
- x, y, width, height);
+ x, y, width, height);
}
static void
gtk_hscale_size_request (GtkWidget *widget,
- GtkRequisition *requisition)
+ GtkRequisition *requisition)
{
GtkScale *scale;
gint value_width;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_HSCALE (widget));
g_return_if_fail (requisition != NULL);
-
+
scale = GTK_SCALE (widget);
-
+
requisition->width = (SCALE_CLASS (scale)->slider_length +
- widget->style->klass->xthickness) * 2;
+ widget->style->klass->xthickness) * 2;
requisition->height = (RANGE_CLASS (scale)->slider_width +
- widget->style->klass->ythickness * 2);
-
+ widget->style->klass->ythickness * 2);
+
if (scale->draw_value)
{
value_width = gtk_scale_value_width (scale);
-
+
if ((scale->value_pos == GTK_POS_LEFT) ||
- (scale->value_pos == GTK_POS_RIGHT))
- {
- requisition->width += value_width + SCALE_CLASS (scale)->value_spacing;
- if (requisition->height < (widget->style->font->ascent + widget->style->font->descent))
- requisition->height = widget->style->font->ascent + widget->style->font->descent;
- }
+ (scale->value_pos == GTK_POS_RIGHT))
+ {
+ requisition->width += value_width + SCALE_CLASS (scale)->value_spacing;
+ if (requisition->height < (widget->style->font->ascent + widget->style->font->descent))
+ requisition->height = widget->style->font->ascent + widget->style->font->descent;
+ }
else if ((scale->value_pos == GTK_POS_TOP) ||
- (scale->value_pos == GTK_POS_BOTTOM))
- {
- if (requisition->width < value_width)
- requisition->width = value_width;
- requisition->height += widget->style->font->ascent + widget->style->font->descent;
- }
+ (scale->value_pos == GTK_POS_BOTTOM))
+ {
+ if (requisition->width < value_width)
+ requisition->width = value_width;
+ requisition->height += widget->style->font->ascent + widget->style->font->descent;
+ }
}
}
static void
gtk_hscale_size_allocate (GtkWidget *widget,
- GtkAllocation *allocation)
+ GtkAllocation *allocation)
{
GtkRange *range;
GtkScale *scale;
gint width, height;
gint x, y;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_HSCALE (widget));
g_return_if_fail (allocation != NULL);
-
+
widget->allocation = *allocation;
if (GTK_WIDGET_REALIZED (widget))
{
range = GTK_RANGE (widget);
scale = GTK_SCALE (widget);
-
+
gtk_hscale_pos_trough (GTK_HSCALE (widget), &x, &y, &width, &height);
-
+
gdk_window_move_resize (range->trough,
- x + widget->allocation.x,
- y + widget->allocation.y, width, height);
+ x + widget->allocation.x,
+ y + widget->allocation.y, width, height);
gtk_range_slider_update (GTK_RANGE (widget));
}
}
static void
gtk_hscale_pos_trough (GtkHScale *hscale,
- gint *x,
- gint *y,
- gint *w,
- gint *h)
+ gint *x,
+ gint *y,
+ gint *w,
+ gint *h)
{
GtkWidget *widget;
GtkScale *scale;
-
+
g_return_if_fail (hscale != NULL);
g_return_if_fail (GTK_IS_HSCALE (hscale));
g_return_if_fail ((x != NULL) && (y != NULL) && (w != NULL) && (h != NULL));
-
+
widget = GTK_WIDGET (hscale);
scale = GTK_SCALE (hscale);
-
+
*w = widget->allocation.width;
*h = (RANGE_CLASS (scale)->slider_width +
- widget->style->klass->ythickness * 2);
-
+ widget->style->klass->ythickness * 2);
+
if (scale->draw_value)
{
*x = 0;
*y = 0;
-
+
switch (scale->value_pos)
- {
- case GTK_POS_LEFT:
- *x += gtk_scale_value_width (scale) + SCALE_CLASS (scale)->value_spacing;
- *y = (widget->allocation.height - *h) / 2;
- *w -= *x;
- break;
- case GTK_POS_RIGHT:
- *w -= gtk_scale_value_width (scale) + SCALE_CLASS (scale)->value_spacing;
- *y = (widget->allocation.height - *h) / 2;
- break;
- case GTK_POS_TOP:
- *y = (widget->style->font->ascent + widget->style->font->descent +
- (widget->allocation.height - widget->requisition.height) / 2);
- break;
- case GTK_POS_BOTTOM:
- *y = (widget->allocation.height - widget->requisition.height) / 2;
- break;
- }
+ {
+ case GTK_POS_LEFT:
+ *x += gtk_scale_value_width (scale) + SCALE_CLASS (scale)->value_spacing;
+ *y = (widget->allocation.height - *h) / 2;
+ *w -= *x;
+ break;
+ case GTK_POS_RIGHT:
+ *w -= gtk_scale_value_width (scale) + SCALE_CLASS (scale)->value_spacing;
+ *y = (widget->allocation.height - *h) / 2;
+ break;
+ case GTK_POS_TOP:
+ *y = (widget->style->font->ascent + widget->style->font->descent +
+ (widget->allocation.height - widget->requisition.height) / 2);
+ break;
+ case GTK_POS_BOTTOM:
+ *y = (widget->allocation.height - widget->requisition.height) / 2;
+ break;
+ }
}
else
{
static void
gtk_hscale_pos_background (GtkHScale *hscale,
- gint *x,
- gint *y,
- gint *w,
- gint *h)
+ gint *x,
+ gint *y,
+ gint *w,
+ gint *h)
{
GtkWidget *widget;
GtkScale *scale;
-
+
gint tx, ty, twidth, theight;
-
+
g_return_if_fail (hscale != NULL);
g_return_if_fail (GTK_IS_HSCALE (hscale));
g_return_if_fail ((x != NULL) && (y != NULL) && (w != NULL) && (h != NULL));
-
+
gtk_hscale_pos_trough (hscale, &tx, &ty, &twidth, &theight);
widget = GTK_WIDGET (hscale);
scale = GTK_SCALE (hscale);
-
+
*x = widget->allocation.x;
*y = widget->allocation.y;
*w = widget->allocation.width;
*h = widget->allocation.height;
-
+
switch (scale->value_pos)
{
case GTK_POS_LEFT:
gtk_hscale_draw_slider (GtkRange *range)
{
GtkStateType state_type;
-
+
g_return_if_fail (range != NULL);
g_return_if_fail (GTK_IS_HSCALE (range));
-
+
if (range->slider)
{
if ((range->in_child == RANGE_CLASS (range)->slider) ||
state_type = GTK_STATE_PRELIGHT;
else
state_type = GTK_STATE_NORMAL;
-
- gtk_paint_slider(GTK_WIDGET (range)->style, range->slider, state_type,
+
+ gtk_paint_slider (GTK_WIDGET (range)->style, range->slider, state_type,
GTK_SHADOW_OUT,
NULL, GTK_WIDGET (range), "hscale",
0, 0, -1, -1,
gint text_width;
gint width, height;
gint x, y;
-
+
g_return_if_fail (scale != NULL);
g_return_if_fail (GTK_IS_HSCALE (scale));
-
+
widget = GTK_WIDGET (scale);
if (scale->draw_value)
{
sprintf (buffer, "%0.*f", GTK_RANGE (scale)->digits, GTK_RANGE (scale)->adjustment->value);
text_width = gdk_string_measure (GTK_WIDGET (scale)->style->font, buffer);
-
+
switch (scale->value_pos)
- {
- case GTK_POS_LEFT:
- gdk_window_get_position (GTK_RANGE (scale)->trough, &x, &y);
- gdk_window_get_size (GTK_RANGE (scale)->trough, &width, &height);
-
- x -= SCALE_CLASS (scale)->value_spacing + text_width;
- y += ((height -
- (GTK_WIDGET (scale)->style->font->ascent +
- GTK_WIDGET (scale)->style->font->descent)) / 2 +
- GTK_WIDGET (scale)->style->font->ascent);
- break;
- case GTK_POS_RIGHT:
- gdk_window_get_position (GTK_RANGE (scale)->trough, &x, &y);
- gdk_window_get_size (GTK_RANGE (scale)->trough, &width, &height);
-
- x += width + SCALE_CLASS (scale)->value_spacing;
- y += ((height -
- (GTK_WIDGET (scale)->style->font->ascent +
- GTK_WIDGET (scale)->style->font->descent)) / 2 +
- GTK_WIDGET (scale)->style->font->ascent);
- break;
- case GTK_POS_TOP:
- gdk_window_get_position (GTK_RANGE (scale)->slider, &x, NULL);
- gdk_window_get_position (GTK_RANGE (scale)->trough, NULL, &y);
- gdk_window_get_size (GTK_RANGE (scale)->slider, &width, NULL);
- gdk_window_get_size (GTK_RANGE (scale)->trough, NULL, &height);
-
- x += widget->allocation.x + (width - text_width) / 2;
- y -= GTK_WIDGET (scale)->style->font->descent;
- break;
- case GTK_POS_BOTTOM:
- gdk_window_get_position (GTK_RANGE (scale)->slider, &x, NULL);
- gdk_window_get_position (GTK_RANGE (scale)->trough, NULL, &y);
- gdk_window_get_size (GTK_RANGE (scale)->slider, &width, NULL);
- gdk_window_get_size (GTK_RANGE (scale)->trough, NULL, &height);
-
- x += widget->allocation.x + (width - text_width) / 2;
- y += height + GTK_WIDGET (scale)->style->font->ascent;
- break;
- }
-
+ {
+ case GTK_POS_LEFT:
+ gdk_window_get_position (GTK_RANGE (scale)->trough, &x, &y);
+ gdk_window_get_size (GTK_RANGE (scale)->trough, &width, &height);
+
+ x -= SCALE_CLASS (scale)->value_spacing + text_width;
+ y += ((height -
+ (GTK_WIDGET (scale)->style->font->ascent +
+ GTK_WIDGET (scale)->style->font->descent)) / 2 +
+ GTK_WIDGET (scale)->style->font->ascent);
+ break;
+ case GTK_POS_RIGHT:
+ gdk_window_get_position (GTK_RANGE (scale)->trough, &x, &y);
+ gdk_window_get_size (GTK_RANGE (scale)->trough, &width, &height);
+
+ x += width + SCALE_CLASS (scale)->value_spacing;
+ y += ((height -
+ (GTK_WIDGET (scale)->style->font->ascent +
+ GTK_WIDGET (scale)->style->font->descent)) / 2 +
+ GTK_WIDGET (scale)->style->font->ascent);
+ break;
+ case GTK_POS_TOP:
+ gdk_window_get_position (GTK_RANGE (scale)->slider, &x, NULL);
+ gdk_window_get_position (GTK_RANGE (scale)->trough, NULL, &y);
+ gdk_window_get_size (GTK_RANGE (scale)->slider, &width, NULL);
+ gdk_window_get_size (GTK_RANGE (scale)->trough, NULL, &height);
+
+ x += widget->allocation.x + (width - text_width) / 2;
+ y -= GTK_WIDGET (scale)->style->font->descent;
+ break;
+ case GTK_POS_BOTTOM:
+ gdk_window_get_position (GTK_RANGE (scale)->slider, &x, NULL);
+ gdk_window_get_position (GTK_RANGE (scale)->trough, NULL, &y);
+ gdk_window_get_size (GTK_RANGE (scale)->slider, &width, NULL);
+ gdk_window_get_size (GTK_RANGE (scale)->trough, NULL, &height);
+
+ x += widget->allocation.x + (width - text_width) / 2;
+ y += height + GTK_WIDGET (scale)->style->font->ascent;
+ break;
+ }
+
state_type = GTK_STATE_NORMAL;
if (!GTK_WIDGET_IS_SENSITIVE (scale))
- state_type = GTK_STATE_INSENSITIVE;
-
- gtk_paint_string (GTK_WIDGET (scale)->style,
- GTK_WIDGET (scale)->window,
- state_type,
- NULL, GTK_WIDGET (scale), "hscale",
- x, y, buffer);
+ state_type = GTK_STATE_INSENSITIVE;
+
+ gtk_paint_string (GTK_WIDGET (scale)->style,
+ GTK_WIDGET (scale)->window,
+ state_type,
+ NULL, GTK_WIDGET (scale), "hscale",
+ x, y, buffer);
}
}
static gint
-gtk_hscale_trough_keys(GtkRange *range,
- GdkEventKey *key,
- GtkScrollType *scroll,
- GtkTroughType *pos)
+gtk_hscale_trough_keys (GtkRange *range,
+ GdkEventKey *key,
+ GtkScrollType *scroll,
+ GtkTroughType *pos)
{
gint return_val = FALSE;
switch (key->keyval)
case GDK_Left:
return_val = TRUE;
if (key->state & GDK_CONTROL_MASK)
- *scroll = GTK_SCROLL_PAGE_BACKWARD;
+ *scroll = GTK_SCROLL_PAGE_BACKWARD;
else
- *scroll = GTK_SCROLL_STEP_BACKWARD;
+ *scroll = GTK_SCROLL_STEP_BACKWARD;
break;
case GDK_Right:
return_val = TRUE;
if (key->state & GDK_CONTROL_MASK)
- *scroll = GTK_SCROLL_PAGE_FORWARD;
+ *scroll = GTK_SCROLL_PAGE_FORWARD;
else
- *scroll = GTK_SCROLL_STEP_FORWARD;
+ *scroll = GTK_SCROLL_STEP_FORWARD;
break;
case GDK_Home:
return_val = TRUE;
#endif /* __cplusplus */
-#define GTK_HSCALE(obj) GTK_CHECK_CAST (obj, gtk_hscale_get_type (), GtkHScale)
-#define GTK_HSCALE_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_hscale_get_type (), GtkHScaleClass)
-#define GTK_IS_HSCALE(obj) GTK_CHECK_TYPE (obj, gtk_hscale_get_type ())
+#define GTK_TYPE_HSCALE (gtk_hscale_get_type ())
+#define GTK_HSCALE(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_HSCALE, GtkHScale))
+#define GTK_HSCALE_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_HSCALE, GtkHScaleClass))
+#define GTK_IS_HSCALE(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_HSCALE))
+#define GTK_IS_HSCALE_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_HSCALE))
+
typedef struct _GtkHScale GtkHScale;
};
-guint gtk_hscale_get_type (void);
+GtkType gtk_hscale_get_type (void);
GtkWidget* gtk_hscale_new (GtkAdjustment *adjustment);
#define RANGE_CLASS(w) GTK_RANGE_CLASS (GTK_OBJECT (w)->klass)
+enum {
+ ARG_0,
+ ARG_ADJUSTMENT,
+};
static void gtk_hscrollbar_class_init (GtkHScrollbarClass *klass);
static void gtk_hscrollbar_init (GtkHScrollbar *hscrollbar);
+static void gtk_hscrollbar_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
+static void gtk_hscrollbar_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
static void gtk_hscrollbar_realize (GtkWidget *widget);
static void gtk_hscrollbar_size_allocate (GtkWidget *widget,
- GtkAllocation *allocation);
+ GtkAllocation *allocation);
static void gtk_hscrollbar_draw_step_forw (GtkRange *range);
static void gtk_hscrollbar_draw_step_back (GtkRange *range);
static void gtk_hscrollbar_slider_update (GtkRange *range);
static void gtk_hscrollbar_calc_slider_size (GtkHScrollbar *hscrollbar);
static gint gtk_hscrollbar_trough_keys (GtkRange *range,
- GdkEventKey *key,
- GtkScrollType *scroll,
- GtkTroughType *pos);
+ GdkEventKey *key,
+ GtkScrollType *scroll,
+ GtkTroughType *pos);
-guint
+GtkType
gtk_hscrollbar_get_type (void)
{
- static guint hscrollbar_type = 0;
-
+ static GtkType hscrollbar_type = 0;
+
if (!hscrollbar_type)
{
GtkTypeInfo hscrollbar_info =
{
- "GtkHScrollbar",
- sizeof (GtkHScrollbar),
- sizeof (GtkHScrollbarClass),
- (GtkClassInitFunc) gtk_hscrollbar_class_init,
- (GtkObjectInitFunc) gtk_hscrollbar_init,
- /* reserved_1 */ NULL,
+ "GtkHScrollbar",
+ sizeof (GtkHScrollbar),
+ sizeof (GtkHScrollbarClass),
+ (GtkClassInitFunc) gtk_hscrollbar_class_init,
+ (GtkObjectInitFunc) gtk_hscrollbar_init,
+ /* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
};
-
- hscrollbar_type = gtk_type_unique (gtk_scrollbar_get_type (), &hscrollbar_info);
+
+ hscrollbar_type = gtk_type_unique (GTK_TYPE_SCROLLBAR, &hscrollbar_info);
}
-
+
return hscrollbar_type;
}
static void
gtk_hscrollbar_class_init (GtkHScrollbarClass *class)
{
+ GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
GtkRangeClass *range_class;
-
+
+ object_class = (GtkObjectClass*) class;
widget_class = (GtkWidgetClass*) class;
range_class = (GtkRangeClass*) class;
-
+
+ gtk_object_add_arg_type ("GtkHScrollbar::adjustment",
+ GTK_TYPE_ADJUSTMENT,
+ GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
+ ARG_ADJUSTMENT);
+
+ object_class->set_arg = gtk_hscrollbar_set_arg;
+ object_class->get_arg = gtk_hscrollbar_get_arg;
+
widget_class->realize = gtk_hscrollbar_realize;
widget_class->size_allocate = gtk_hscrollbar_size_allocate;
-
+
range_class->draw_step_forw = gtk_hscrollbar_draw_step_forw;
range_class->draw_step_back = gtk_hscrollbar_draw_step_back;
range_class->slider_update = gtk_hscrollbar_slider_update;
range_class->motion = gtk_range_default_hmotion;
}
+static void
+gtk_hscrollbar_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkHScrollbar *hscrollbar;
+
+ hscrollbar = GTK_HSCROLLBAR (object);
+
+ switch (arg_id)
+ {
+ case ARG_ADJUSTMENT:
+ gtk_range_set_adjustment (GTK_RANGE (hscrollbar), GTK_VALUE_POINTER (*arg));
+ break;
+ default:
+ break;
+ }
+}
+
+static void
+gtk_hscrollbar_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkHScrollbar *hscrollbar;
+
+ hscrollbar = GTK_HSCROLLBAR (object);
+
+ switch (arg_id)
+ {
+ case ARG_ADJUSTMENT:
+ GTK_VALUE_POINTER (*arg) = GTK_RANGE (hscrollbar);
+ break;
+ default:
+ arg->type = GTK_TYPE_INVALID;
+ break;
+ }
+}
+
static void
gtk_hscrollbar_init (GtkHScrollbar *hscrollbar)
{
GtkWidget *widget;
GtkRequisition *requisition;
-
+
widget = GTK_WIDGET (hscrollbar);
requisition = &widget->requisition;
-
+
requisition->width = (RANGE_CLASS (widget)->min_slider_size +
- RANGE_CLASS (widget)->stepper_size +
- RANGE_CLASS (widget)->stepper_slider_spacing +
- widget->style->klass->xthickness) * 2;
+ RANGE_CLASS (widget)->stepper_size +
+ RANGE_CLASS (widget)->stepper_slider_spacing +
+ widget->style->klass->xthickness) * 2;
requisition->height = (RANGE_CLASS (widget)->slider_width +
- widget->style->klass->ythickness * 2);
+ widget->style->klass->ythickness * 2);
}
GtkWidget*
gtk_hscrollbar_new (GtkAdjustment *adjustment)
{
- GtkHScrollbar *hscrollbar;
-
- hscrollbar = gtk_type_new (gtk_hscrollbar_get_type ());
-
- if (!adjustment)
- adjustment = (GtkAdjustment*) gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
-
- gtk_range_set_adjustment (GTK_RANGE (hscrollbar), adjustment);
+ GtkWidget *hscrollbar;
+
+ hscrollbar = gtk_widget_new (GTK_TYPE_HSCROLLBAR,
+ "adjustment", adjustment,
+ NULL);
- return GTK_WIDGET (hscrollbar);
+ return hscrollbar;
}
GtkRange *range;
GdkWindowAttr attributes;
gint attributes_mask;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_HSCROLLBAR (widget));
-
+
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
range = GTK_RANGE (widget);
-
+
attributes.x = widget->allocation.x;
attributes.y = widget->allocation.y + (widget->allocation.height - widget->requisition.height) / 2;
attributes.width = widget->allocation.width;
attributes.colormap = gtk_widget_get_colormap (widget);
attributes.event_mask = gtk_widget_get_events (widget);
attributes.event_mask |= (GDK_EXPOSURE_MASK |
- GDK_BUTTON_PRESS_MASK |
- GDK_BUTTON_RELEASE_MASK |
- GDK_ENTER_NOTIFY_MASK |
- GDK_LEAVE_NOTIFY_MASK);
-
+ GDK_BUTTON_PRESS_MASK |
+ GDK_BUTTON_RELEASE_MASK |
+ GDK_ENTER_NOTIFY_MASK |
+ GDK_LEAVE_NOTIFY_MASK);
+
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
-
+
range->trough = widget->window;
gdk_window_ref (range->trough);
-
+
attributes.x = widget->style->klass->xthickness;
attributes.y = widget->style->klass->ythickness;
attributes.width = RANGE_CLASS (widget)->stepper_size;
attributes.height = RANGE_CLASS (widget)->stepper_size;
-
+
range->step_back = gdk_window_new (range->trough, &attributes, attributes_mask);
-
+
attributes.x = (widget->allocation.width -
- widget->style->klass->xthickness -
- RANGE_CLASS (widget)->stepper_size);
-
+ widget->style->klass->xthickness -
+ RANGE_CLASS (widget)->stepper_size);
+
range->step_forw = gdk_window_new (range->trough, &attributes, attributes_mask);
-
+
attributes.x = 0;
attributes.y = widget->style->klass->ythickness;
attributes.width = RANGE_CLASS (widget)->min_slider_size;
attributes.height = RANGE_CLASS (widget)->slider_width;
attributes.event_mask |= (GDK_BUTTON_MOTION_MASK |
- GDK_POINTER_MOTION_HINT_MASK);
-
+ GDK_POINTER_MOTION_HINT_MASK);
+
range->slider = gdk_window_new (range->trough, &attributes, attributes_mask);
-
+
gtk_hscrollbar_calc_slider_size (GTK_HSCROLLBAR (widget));
gtk_range_slider_update (GTK_RANGE (widget));
-
+
widget->style = gtk_style_attach (widget->style, widget->window);
-
+
gdk_window_set_user_data (range->trough, widget);
gdk_window_set_user_data (range->slider, widget);
gdk_window_set_user_data (range->step_forw, widget);
gdk_window_set_user_data (range->step_back, widget);
-
+
gtk_style_set_background (widget->style, range->trough, GTK_STATE_ACTIVE);
gtk_style_set_background (widget->style, range->slider, GTK_STATE_NORMAL);
gtk_style_set_background (widget->style, range->step_forw, GTK_STATE_ACTIVE);
gtk_style_set_background (widget->style, range->step_back, GTK_STATE_ACTIVE);
-
+
gdk_window_show (range->slider);
gdk_window_show (range->step_forw);
gdk_window_show (range->step_back);
static void
gtk_hscrollbar_size_allocate (GtkWidget *widget,
- GtkAllocation *allocation)
+ GtkAllocation *allocation)
{
GtkRange *range;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_HSCROLLBAR (widget));
g_return_if_fail (allocation != NULL);
-
+
widget->allocation = *allocation;
if (GTK_WIDGET_REALIZED (widget))
{
range = GTK_RANGE (widget);
-
+
gdk_window_move_resize (range->trough,
- allocation->x,
- allocation->y + (allocation->height - widget->requisition.height) / 2,
- allocation->width, widget->requisition.height);
+ allocation->x,
+ allocation->y + (allocation->height - widget->requisition.height) / 2,
+ allocation->width, widget->requisition.height);
gdk_window_move_resize (range->step_back,
- widget->style->klass->xthickness,
- widget->style->klass->ythickness,
- RANGE_CLASS (widget)->stepper_size,
- widget->requisition.height - widget->style->klass->ythickness * 2);
+ widget->style->klass->xthickness,
+ widget->style->klass->ythickness,
+ RANGE_CLASS (widget)->stepper_size,
+ widget->requisition.height - widget->style->klass->ythickness * 2);
gdk_window_move_resize (range->step_forw,
- allocation->width - widget->style->klass->xthickness -
- RANGE_CLASS (widget)->stepper_size,
- widget->style->klass->ythickness,
- RANGE_CLASS (widget)->stepper_size,
- widget->requisition.height - widget->style->klass->ythickness * 2);
+ allocation->width - widget->style->klass->xthickness -
+ RANGE_CLASS (widget)->stepper_size,
+ widget->style->klass->ythickness,
+ RANGE_CLASS (widget)->stepper_size,
+ widget->requisition.height - widget->style->klass->ythickness * 2);
gdk_window_resize (range->slider,
- RANGE_CLASS (widget)->min_slider_size,
- widget->requisition.height - widget->style->klass->ythickness * 2);
-
+ RANGE_CLASS (widget)->min_slider_size,
+ widget->requisition.height - widget->style->klass->ythickness * 2);
+
gtk_range_slider_update (GTK_RANGE (widget));
}
}
{
GtkStateType state_type;
GtkShadowType shadow_type;
-
+
g_return_if_fail (range != NULL);
g_return_if_fail (GTK_IS_HSCROLLBAR (range));
-
+
if (GTK_WIDGET_DRAWABLE (range))
{
if (range->in_child == RANGE_CLASS (range)->step_forw)
- {
- if (range->click_child == RANGE_CLASS (range)->step_forw)
- state_type = GTK_STATE_ACTIVE;
- else
- state_type = GTK_STATE_PRELIGHT;
- }
+ {
+ if (range->click_child == RANGE_CLASS (range)->step_forw)
+ state_type = GTK_STATE_ACTIVE;
+ else
+ state_type = GTK_STATE_PRELIGHT;
+ }
else
- state_type = GTK_STATE_NORMAL;
-
+ state_type = GTK_STATE_NORMAL;
+
if (range->click_child == RANGE_CLASS (range)->step_forw)
- shadow_type = GTK_SHADOW_IN;
+ shadow_type = GTK_SHADOW_IN;
else
- shadow_type = GTK_SHADOW_OUT;
-
+ shadow_type = GTK_SHADOW_OUT;
+
gtk_paint_arrow (GTK_WIDGET (range)->style, range->step_forw,
- state_type, shadow_type,
- NULL, GTK_WIDGET (range), "hscrollbar",
- GTK_ARROW_RIGHT,
- TRUE, 0, 0, -1, -1);
+ state_type, shadow_type,
+ NULL, GTK_WIDGET (range), "hscrollbar",
+ GTK_ARROW_RIGHT,
+ TRUE, 0, 0, -1, -1);
}
}
{
GtkStateType state_type;
GtkShadowType shadow_type;
-
+
g_return_if_fail (range != NULL);
g_return_if_fail (GTK_IS_HSCROLLBAR (range));
-
+
if (GTK_WIDGET_DRAWABLE (range))
{
if (range->in_child == RANGE_CLASS (range)->step_back)
- {
- if (range->click_child == RANGE_CLASS (range)->step_back)
- state_type = GTK_STATE_ACTIVE;
- else
- state_type = GTK_STATE_PRELIGHT;
- }
+ {
+ if (range->click_child == RANGE_CLASS (range)->step_back)
+ state_type = GTK_STATE_ACTIVE;
+ else
+ state_type = GTK_STATE_PRELIGHT;
+ }
else
- state_type = GTK_STATE_NORMAL;
-
+ state_type = GTK_STATE_NORMAL;
+
if (range->click_child == RANGE_CLASS (range)->step_back)
- shadow_type = GTK_SHADOW_IN;
+ shadow_type = GTK_SHADOW_IN;
else
- shadow_type = GTK_SHADOW_OUT;
-
- gtk_paint_arrow (GTK_WIDGET (range)->style, range->step_back,
- state_type, shadow_type,
- NULL, GTK_WIDGET (range), "hscrollbar",
- GTK_ARROW_LEFT,
- TRUE, 0, 0, -1, -1);
+ shadow_type = GTK_SHADOW_OUT;
+
+ gtk_paint_arrow (GTK_WIDGET (range)->style, range->step_back,
+ state_type, shadow_type,
+ NULL, GTK_WIDGET (range), "hscrollbar",
+ GTK_ARROW_LEFT,
+ TRUE, 0, 0, -1, -1);
}
}
{
g_return_if_fail (range != NULL);
g_return_if_fail (GTK_IS_HSCROLLBAR (range));
-
+
gtk_hscrollbar_calc_slider_size (GTK_HSCROLLBAR (range));
gtk_range_default_hslider_update (range);
}
gint slider_height;
gint left, right;
gint width;
-
+
g_return_if_fail (hscrollbar != NULL);
g_return_if_fail (GTK_IS_HSCROLLBAR (hscrollbar));
-
+
if (GTK_WIDGET_REALIZED (hscrollbar))
{
range = GTK_RANGE (hscrollbar);
-
+
gdk_window_get_size (range->step_back, &step_back_width, NULL);
gdk_window_get_position (range->step_back, &step_back_x, NULL);
gdk_window_get_position (range->step_forw, &step_forw_x, NULL);
-
+
left = (step_back_x +
- step_back_width +
- RANGE_CLASS (hscrollbar)->stepper_slider_spacing);
+ step_back_width +
+ RANGE_CLASS (hscrollbar)->stepper_slider_spacing);
right = step_forw_x - RANGE_CLASS (hscrollbar)->stepper_slider_spacing;
width = right - left;
-
+
if ((range->adjustment->page_size > 0) &&
- (range->adjustment->lower != range->adjustment->upper))
- {
- if (range->adjustment->page_size >
- (range->adjustment->upper - range->adjustment->lower))
- range->adjustment->page_size = range->adjustment->upper - range->adjustment->lower;
-
- width = (width * range->adjustment->page_size /
- (range->adjustment->upper - range->adjustment->lower));
-
- if (width < RANGE_CLASS (hscrollbar)->min_slider_size)
- width = RANGE_CLASS (hscrollbar)->min_slider_size;
- }
-
+ (range->adjustment->lower != range->adjustment->upper))
+ {
+ if (range->adjustment->page_size >
+ (range->adjustment->upper - range->adjustment->lower))
+ range->adjustment->page_size = range->adjustment->upper - range->adjustment->lower;
+
+ width = (width * range->adjustment->page_size /
+ (range->adjustment->upper - range->adjustment->lower));
+
+ if (width < RANGE_CLASS (hscrollbar)->min_slider_size)
+ width = RANGE_CLASS (hscrollbar)->min_slider_size;
+ }
+
gdk_window_get_size (range->slider, &slider_width, &slider_height);
-
+
if (slider_width != width)
- gdk_window_resize (range->slider, width, slider_height);
+ gdk_window_resize (range->slider, width, slider_height);
}
}
static gint
gtk_hscrollbar_trough_keys(GtkRange *range,
- GdkEventKey *key,
- GtkScrollType *scroll,
- GtkTroughType *pos)
+ GdkEventKey *key,
+ GtkScrollType *scroll,
+ GtkTroughType *pos)
{
gint return_val = FALSE;
switch (key->keyval)
case GDK_Home:
return_val = TRUE;
if (key->state & GDK_CONTROL_MASK)
- *scroll = GTK_SCROLL_PAGE_BACKWARD;
+ *scroll = GTK_SCROLL_PAGE_BACKWARD;
else
- *pos = GTK_TROUGH_START;
+ *pos = GTK_TROUGH_START;
break;
case GDK_End:
return_val = TRUE;
if (key->state & GDK_CONTROL_MASK)
- *scroll = GTK_SCROLL_PAGE_FORWARD;
+ *scroll = GTK_SCROLL_PAGE_FORWARD;
else
- *pos = GTK_TROUGH_END;
+ *pos = GTK_TROUGH_END;
break;
}
return return_val;
#endif /* __cplusplus */
-#define GTK_HSCROLLBAR(obj) GTK_CHECK_CAST (obj, gtk_hscrollbar_get_type (), GtkHScrollbar)
-#define GTK_HSCROLLBAR_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_hscrollbar_get_type (), GtkHScrollbarClass)
-#define GTK_IS_HSCROLLBAR(obj) GTK_CHECK_TYPE (obj, gtk_hscrollbar_get_type ())
+#define GTK_TYPE_HSCROLLBAR (gtk_hscrollbar_get_type ())
+#define GTK_HSCROLLBAR(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_HSCROLLBAR, GtkHScrollbar))
+#define GTK_HSCROLLBAR_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_HSCROLLBAR, GtkHScrollbarClass))
+#define GTK_IS_HSCROLLBAR(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_HSCROLLBAR))
+#define GTK_IS_HSCROLLBAR_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_HSCROLLBAR))
typedef struct _GtkHScrollbar GtkHScrollbar;
};
-guint gtk_hscrollbar_get_type (void);
+GtkType gtk_hscrollbar_get_type (void);
GtkWidget* gtk_hscrollbar_new (GtkAdjustment *adjustment);
static void
gtk_misc_init (GtkMisc *misc)
{
- GTK_WIDGET_SET_FLAGS (misc, GTK_BASIC);
-
misc->xalign = 0.5;
misc->yalign = 0.5;
misc->xpad = 0;
gtk_object_add_arg_type ("GtkNotebook::page", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_PAGE);
gtk_object_add_arg_type ("GtkNotebook::tab_pos", GTK_TYPE_POSITION_TYPE, GTK_ARG_READWRITE, ARG_TAB_POS);
- gtk_object_add_arg_type ("GtkNotebook::tab_border", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_TAB_BORDER);
+ gtk_object_add_arg_type ("GtkNotebook::tab_border", GTK_TYPE_UINT, GTK_ARG_WRITABLE, ARG_TAB_BORDER);
gtk_object_add_arg_type ("GtkNotebook::tab_hborder", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_TAB_HBORDER);
gtk_object_add_arg_type ("GtkNotebook::tab_vborder", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_TAB_VBORDER);
gtk_object_add_arg_type ("GtkNotebook::show_tabs", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_SHOW_TABS);
notebook->panel = NULL;
notebook->menu = NULL;
- notebook->tab_border = 2;
notebook->tab_hborder = 2;
notebook->tab_vborder = 2;
case ARG_TAB_POS:
GTK_VALUE_ENUM (*arg) = notebook->tab_pos;
break;
- case ARG_TAB_BORDER:
- GTK_VALUE_UINT (*arg) = notebook->tab_border;
- break;
case ARG_TAB_HBORDER:
GTK_VALUE_UINT (*arg) = notebook->tab_hborder;
break;
g_return_if_fail (notebook != NULL);
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
- notebook->tab_border = tab_border;
notebook->tab_hborder = tab_border;
notebook->tab_vborder = tab_border;
guint32 timer;
- guint16 tab_border; /* deprecated field,
- * use tab_hborder, tab_vborder instead
- */
guint16 tab_hborder;
guint16 tab_vborder;
void gtk_object_init_type (void);
static void gtk_object_base_class_init (GtkObjectClass *klass);
static void gtk_object_class_init (GtkObjectClass *klass);
-static void gtk_object_init (GtkObject *object);
+static void gtk_object_init (GtkObject *object,
+ GtkObjectClass *klass);
static void gtk_object_set_arg (GtkObject *object,
GtkArg *arg,
guint arg_id);
static GHashTable *object_arg_info_ht = NULL;
-static const gchar *user_data_key = "user_data";
-static guint user_data_key_id = 0;
-static const gchar *weakrefs_key = "gtk-weakrefs";
-static guint weakrefs_key_id = 0;
+static GQuark quark_user_data = 0;
+static GQuark quark_weakrefs = 0;
+static GQuark quark_carg_history = 0;
#ifdef G_ENABLE_DEBUG
class->signals = NULL;
class->nsignals = 0;
class->n_args = 0;
+ class->construct_args = NULL;
/* reset instance specifc methods that don't get inherited */
class->get_arg = NULL;
static void
gtk_object_class_init (GtkObjectClass *class)
{
+ quark_carg_history = g_quark_from_static_string ("gtk-construct-arg-history");
+
gtk_object_add_arg_type ("GtkObject::user_data",
GTK_TYPE_POINTER,
GTK_ARG_READWRITE,
}
static void
-gtk_object_init (GtkObject *object)
+gtk_object_init (GtkObject *object,
+ GtkObjectClass *klass)
{
+ gboolean needs_construction = FALSE;
+
GTK_OBJECT_FLAGS (object) = GTK_FLOATING;
+ do
+ {
+ needs_construction |= klass->construct_args != NULL;
+ klass = gtk_type_parent_class (klass->type);
+ }
+ while (klass && !needs_construction);
+ if (!needs_construction)
+ GTK_OBJECT_FLAGS (object) |= GTK_CONSTRUCTED;
object->ref_count = 1;
g_datalist_init (&object->object_data);
{
g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_OBJECT (object));
+ g_return_if_fail (GTK_OBJECT_CONSTRUCTED (object));
if (!GTK_OBJECT_DESTROYED (object))
{
g_return_val_if_fail (class != NULL, 0);
+ g_message ("gtk_object_class_add_user_signal() is deprecated");
+
if (nparams > 0)
{
params = g_new (GtkType, nparams);
g_return_if_fail (notify != NULL);
g_return_if_fail (GTK_IS_OBJECT (object));
- if (!weakrefs_key_id)
- weakrefs_key_id = g_quark_from_static_string (weakrefs_key);
+ if (!quark_weakrefs)
+ quark_weakrefs = g_quark_from_static_string ("gtk-weakrefs");
weak = g_new (GtkWeakRef, 1);
- weak->next = gtk_object_get_data_by_id (object, weakrefs_key_id);
+ weak->next = gtk_object_get_data_by_id (object, quark_weakrefs);
weak->notify = notify;
weak->data = data;
- gtk_object_set_data_by_id (object, weakrefs_key_id, weak);
+ gtk_object_set_data_by_id (object, quark_weakrefs, weak);
}
void
g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_OBJECT (object));
- if (!weakrefs_key_id)
+ if (!quark_weakrefs)
return;
- weaks = gtk_object_get_data_by_id (object, weakrefs_key_id);
+ weaks = gtk_object_get_data_by_id (object, quark_weakrefs);
for (wp = &weaks; *wp; wp = &(*wp)->next)
{
w = *wp;
if (w->notify == notify && w->data == data)
{
if (w == weaks)
- gtk_object_set_data_by_id (object, weakrefs_key_id, w->next);
+ gtk_object_set_data_by_id (object, quark_weakrefs, w->next);
else
*wp = w->next;
g_free (w);
static void
gtk_object_notify_weaks (GtkObject *object)
{
- if (weakrefs_key_id)
+ if (quark_weakrefs)
{
GtkWeakRef *w1, *w2;
- w1 = gtk_object_get_data_by_id (object, weakrefs_key_id);
+ w1 = gtk_object_get_data_by_id (object, quark_weakrefs);
while (w1)
{
gtk_args_collect_cleanup (arg_list, info_list);
}
+ if (!GTK_OBJECT_CONSTRUCTED (object))
+ gtk_object_default_construct (object);
+
return object;
}
for (max_args = args + n_args; args < max_args; args++)
gtk_object_arg_set (object, args, NULL);
+ if (!GTK_OBJECT_CONSTRUCTED (object))
+ gtk_object_default_construct (object);
+
return object;
}
}
void
-gtk_object_arg_set (GtkObject *object,
- GtkArg *arg,
- GtkArgInfo *info)
+gtk_object_arg_set (GtkObject *object,
+ GtkArg *arg,
+ GtkArgInfo *info)
{
GtkObjectClass *oclass;
return;
}
}
-
- if (! (info->arg_flags & GTK_ARG_WRITABLE))
+
+ if (info->arg_flags & GTK_ARG_CONSTRUCT_ONLY &&
+ GTK_OBJECT_CONSTRUCTED (object))
+ {
+ g_warning ("gtk_object_arg_set(): cannot set argument \"%s\" for constructed object",
+ info->full_name);
+ return;
+ }
+ if (!(info->arg_flags & GTK_ARG_WRITABLE))
{
g_warning ("gtk_object_arg_set(): argument \"%s\" is not writable",
info->full_name);
oclass = gtk_type_class (info->class_type);
g_assert (oclass->set_arg != NULL);
oclass->set_arg (object, arg, info->arg_id);
+ if (!GTK_OBJECT_CONSTRUCTED (object) &&
+ (info->arg_flags & GTK_ARG_CONSTRUCT_ONLY ||
+ info->arg_flags & GTK_ARG_CONSTRUCT))
+ {
+ GSList *slist;
+
+ slist = gtk_object_get_data_by_id (object, quark_carg_history);
+ gtk_object_set_data_by_id (object,
+ quark_carg_history,
+ g_slist_prepend (slist, info));
+ }
}
void
-gtk_object_arg_get (GtkObject *object,
- GtkArg *arg,
- GtkArgInfo *info)
+gtk_object_arg_get (GtkObject *object,
+ GtkArg *arg,
+ GtkArgInfo *info)
{
GtkObjectClass *oclass;
oclass->get_arg (object, arg, info->arg_id);
}
+void
+gtk_object_default_construct (GtkObject *object)
+{
+ GSList *slist;
+
+ g_return_if_fail (object != NULL);
+ g_return_if_fail (GTK_IS_OBJECT (object));
+
+ if (!GTK_OBJECT_CONSTRUCTED (object))
+ {
+ for (slist = object->klass->construct_args;
+ slist && !GTK_OBJECT_CONSTRUCTED (object);
+ slist = slist->next)
+ {
+ GSList *history;
+ GtkArgInfo *info;
+
+ info = slist->data;
+ history = gtk_object_get_data_by_id (object, quark_carg_history);
+ if (!g_slist_find (history, info))
+ {
+ GtkArg arg;
+
+ /* default application */
+ arg.type = info->type;
+ arg.name = info->name;
+ switch (gtk_type_get_varargs_type (arg.type))
+ {
+ case GTK_TYPE_FLOAT:
+ GTK_VALUE_FLOAT (arg) = 0.0;
+ break;
+ case GTK_TYPE_DOUBLE:
+ GTK_VALUE_DOUBLE (arg) = 0.0;
+ break;
+ case GTK_TYPE_BOXED:
+ case GTK_TYPE_STRING:
+ case GTK_TYPE_POINTER:
+ case GTK_TYPE_OBJECT:
+ GTK_VALUE_POINTER (arg) = NULL;
+ break;
+ default:
+ memset (&arg.d, 0, sizeof (arg.d));
+ break;
+ }
+ gtk_object_arg_set (object, &arg, info);
+ }
+ }
+
+ if (!GTK_OBJECT_CONSTRUCTED (object))
+ gtk_object_constructed (object);
+ }
+}
+
+void
+gtk_object_constructed (GtkObject *object)
+{
+ g_return_if_fail (object != NULL);
+ g_return_if_fail (GTK_IS_OBJECT (object));
+ g_return_if_fail (GTK_OBJECT_CONSTRUCTED (object) == FALSE);
+
+ g_slist_free (gtk_object_get_data_by_id (object, quark_carg_history));
+ gtk_object_set_data_by_id (object, quark_carg_history, NULL);
+ GTK_OBJECT_FLAGS (object) |= GTK_CONSTRUCTED;
+}
+
void
gtk_object_add_arg_type (const char *arg_name,
GtkType arg_type,
guint arg_flags,
guint arg_id)
{
+ GtkArgInfo *info;
+
g_return_if_fail (arg_name != NULL);
g_return_if_fail (arg_type > GTK_TYPE_NONE);
g_return_if_fail (arg_id > 0);
g_return_if_fail ((arg_flags & GTK_ARG_READWRITE) == GTK_ARG_READWRITE);
else
g_return_if_fail ((arg_flags & GTK_ARG_READWRITE) != 0);
+ if (arg_flags & GTK_ARG_CONSTRUCT_ONLY)
+ g_return_if_fail ((arg_flags & GTK_ARG_WRITABLE) == GTK_ARG_WRITABLE);
if (!object_arg_info_ht)
object_arg_info_ht = g_hash_table_new (gtk_arg_info_hash,
gtk_arg_info_equal);
- gtk_arg_type_new_static (GTK_TYPE_OBJECT,
- arg_name,
- GTK_STRUCT_OFFSET (GtkObjectClass, n_args),
- object_arg_info_ht,
- arg_type,
- arg_flags,
- arg_id);
+ info = gtk_arg_type_new_static (GTK_TYPE_OBJECT,
+ arg_name,
+ GTK_STRUCT_OFFSET (GtkObjectClass, n_args),
+ object_arg_info_ht,
+ arg_type,
+ arg_flags,
+ arg_id);
+ if (info &&
+ (info->arg_flags & GTK_ARG_CONSTRUCT ||
+ info->arg_flags & GTK_ARG_CONSTRUCT_ONLY))
+ {
+ GtkObjectClass *class;
+
+ class = gtk_type_class (info->class_type);
+ if (info->arg_flags & GTK_ARG_CONSTRUCT_ONLY)
+ class->construct_args = g_slist_prepend (class->construct_args, info);
+ else
+ class->construct_args = g_slist_append (class->construct_args, info);
+ }
}
gchar*
g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_OBJECT (object));
- if (!user_data_key_id)
- user_data_key_id = g_quark_from_static_string (user_data_key);
+ if (!quark_user_data)
+ quark_user_data = g_quark_from_static_string ("user_data");
- g_datalist_id_set_data (&object->object_data, user_data_key_id, data);
+ g_datalist_id_set_data (&object->object_data, quark_user_data, data);
}
gpointer
g_return_val_if_fail (object != NULL, NULL);
g_return_val_if_fail (GTK_IS_OBJECT (object), NULL);
- return g_datalist_id_get_data (&object->object_data, user_data_key_id);
+ return g_datalist_id_get_data (&object->object_data, quark_user_data);
}
/*******************************************
GTK_DESTROYED = 1 << 0,
GTK_FLOATING = 1 << 1,
GTK_CONNECTED = 1 << 2,
- GTK_RESERVED_2 = 1 << 3,
- GTK_OBJECT_FLAG_LAST = GTK_RESERVED_2
+ GTK_CONSTRUCTED = 1 << 3,
} GtkObjectFlags;
/* Macros for extracting the object_flags from GtkObject.
*/
#define GTK_OBJECT_FLAGS(obj) (GTK_OBJECT (obj)->flags)
-#define GTK_OBJECT_DESTROYED(obj) (GTK_OBJECT_FLAGS (obj) & GTK_DESTROYED)
-#define GTK_OBJECT_FLOATING(obj) (GTK_OBJECT_FLAGS (obj) & GTK_FLOATING)
-#define GTK_OBJECT_CONNECTED(obj) (GTK_OBJECT_FLAGS (obj) & GTK_CONNECTED)
+#define GTK_OBJECT_DESTROYED(obj) ((GTK_OBJECT_FLAGS (obj) & GTK_DESTROYED) != 0)
+#define GTK_OBJECT_FLOATING(obj) ((GTK_OBJECT_FLAGS (obj) & GTK_FLOATING) != 0)
+#define GTK_OBJECT_CONNECTED(obj) ((GTK_OBJECT_FLAGS (obj) & GTK_CONNECTED) != 0)
+#define GTK_OBJECT_CONSTRUCTED(obj) ((GTK_OBJECT_FLAGS (obj) & GTK_CONSTRUCTED) != 0)
/* Macros for setting and clearing bits in the object_flags field of GtkObject.
*/
*/
typedef enum
{
- GTK_ARG_READABLE = 1 << 0,
- GTK_ARG_WRITABLE = 1 << 1,
- GTK_ARG_CONSTRUCT = 1 << 2,
- GTK_ARG_CHILD_ARG = 1 << 3,
- GTK_ARG_MASK = 0x0f,
+ GTK_ARG_READABLE = 1 << 0,
+ GTK_ARG_WRITABLE = 1 << 1,
+ GTK_ARG_CONSTRUCT = 1 << 2,
+ GTK_ARG_CONSTRUCT_ONLY = 1 << 3,
+ GTK_ARG_CHILD_ARG = 1 << 4,
+ GTK_ARG_MASK = 0x1f,
/* aliases
*/
- GTK_ARG_READWRITE = GTK_ARG_READABLE | GTK_ARG_WRITABLE
+ GTK_ARG_READWRITE = GTK_ARG_READABLE | GTK_ARG_WRITABLE
} GtkArgFlags;
typedef struct _GtkObjectClass GtkObjectClass;
/* The number of arguments per class.
*/
guint n_args;
+ GSList *construct_args;
/* Non overridable class methods to set and get per class arguments */
void (*set_arg) (GtkObject *object,
GtkObject* gtk_object_newv (GtkType object_type,
guint n_args,
GtkArg *args);
+void gtk_object_default_construct (GtkObject *object);
+void gtk_object_constructed (GtkObject *object);
void gtk_object_sink (GtkObject *object);
void gtk_object_ref (GtkObject *object);
void gtk_object_unref (GtkObject *object);
child = GTK_BIN (option_menu->menu_item)->child;
if (child)
{
- gtk_container_block_resize (GTK_CONTAINER (option_menu));
if (GTK_BIN (option_menu)->child)
gtk_container_remove (GTK_CONTAINER (option_menu),
GTK_BIN (option_menu)->child);
if (GTK_WIDGET (option_menu)->state != child->state)
gtk_widget_set_state (child, GTK_WIDGET (option_menu)->state);
gtk_widget_reparent (child, GTK_WIDGET (option_menu));
- gtk_container_unblock_resize (GTK_CONTAINER (option_menu));
}
gtk_widget_size_request (child, &child->requisition);
if (GTK_BIN (option_menu)->child)
{
- gtk_container_block_resize (GTK_CONTAINER (option_menu));
if (GTK_WIDGET (option_menu->menu_item)->state != GTK_BIN (option_menu)->child->state)
gtk_widget_set_state (GTK_BIN (option_menu)->child,
GTK_WIDGET (option_menu->menu_item)->state);
gtk_widget_reparent (GTK_BIN (option_menu)->child, option_menu->menu_item);
gtk_widget_unref (option_menu->menu_item);
option_menu->menu_item = NULL;
- gtk_container_unblock_resize (GTK_CONTAINER (option_menu));
}
}
static void
gtk_packer_init (GtkPacker *packer)
{
- GTK_WIDGET_SET_FLAGS (packer, GTK_NO_WINDOW | GTK_BASIC);
+ GTK_WIDGET_SET_FLAGS (packer, GTK_NO_WINDOW);
packer->children = NULL;
packer->spacing = 0;
static void
gtk_preview_init (GtkPreview *preview)
{
- GTK_WIDGET_SET_FLAGS (preview, GTK_BASIC);
-
preview->buffer = NULL;
preview->buffer_width = 0;
preview->buffer_height = 0;
#define EPSILON 1e-5
+enum {
+ ARG_0,
+ ARG_ACTIVITY_MODE,
+ ARG_SHOW_TEXT,
+ ARG_TEXT_XALIGN,
+ ARG_TEXT_YALIGN
+};
+
+
static void gtk_progress_class_init (GtkProgressClass *klass);
static void gtk_progress_init (GtkProgress *progress);
+static void gtk_progress_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
+static void gtk_progress_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
+static void gtk_progress_destroy (GtkObject *object);
static void gtk_progress_finalize (GtkObject *object);
static void gtk_progress_realize (GtkWidget *widget);
static gint gtk_progress_expose (GtkWidget *widget,
static GtkWidgetClass *parent_class = NULL;
-guint
+GtkType
gtk_progress_get_type (void)
{
- static guint progress_type = 0;
+ static GtkType progress_type = 0;
if (!progress_type)
{
(GtkClassInitFunc) NULL
};
- progress_type = gtk_type_unique (gtk_widget_get_type (), &progress_info);
+ progress_type = gtk_type_unique (GTK_TYPE_WIDGET, &progress_info);
}
return progress_type;
object_class = (GtkObjectClass *) class;
widget_class = (GtkWidgetClass *) class;
-
- parent_class = gtk_type_class (gtk_widget_get_type ());
-
+ parent_class = gtk_type_class (GTK_TYPE_WIDGET);
+
+ gtk_object_add_arg_type ("GtkProgress::activity_mode",
+ GTK_TYPE_BOOL,
+ GTK_ARG_READWRITE,
+ ARG_ACTIVITY_MODE);
+ gtk_object_add_arg_type ("GtkProgress::show_text",
+ GTK_TYPE_BOOL,
+ GTK_ARG_READWRITE,
+ ARG_SHOW_TEXT);
+ gtk_object_add_arg_type ("GtkProgress::text_xalign",
+ GTK_TYPE_FLOAT,
+ GTK_ARG_READWRITE,
+ ARG_TEXT_XALIGN);
+ gtk_object_add_arg_type ("GtkProgress::text_yalign",
+ GTK_TYPE_FLOAT,
+ GTK_ARG_READWRITE,
+ ARG_TEXT_YALIGN);
+
+ object_class->set_arg = gtk_progress_set_arg;
+ object_class->get_arg = gtk_progress_get_arg;
+ object_class->destroy = gtk_progress_destroy;
object_class->finalize = gtk_progress_finalize;
widget_class->realize = gtk_progress_realize;
}
static void
-gtk_progress_init (GtkProgress *progress)
+gtk_progress_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
{
- GTK_WIDGET_SET_FLAGS (progress, GTK_BASIC);
+ GtkProgress *progress;
+
+ progress = GTK_PROGRESS (object);
+
+ switch (arg_id)
+ {
+ case ARG_ACTIVITY_MODE:
+ gtk_progress_set_activity_mode (progress, GTK_VALUE_BOOL (*arg));
+ break;
+ case ARG_SHOW_TEXT:
+ gtk_progress_set_show_text (progress, GTK_VALUE_BOOL (*arg));
+ break;
+ case ARG_TEXT_XALIGN:
+ gtk_progress_set_text_alignment (progress, GTK_VALUE_FLOAT (*arg), progress->y_align);
+ break;
+ case ARG_TEXT_YALIGN:
+ gtk_progress_set_text_alignment (progress, progress->x_align, GTK_VALUE_FLOAT (*arg));
+ break;
+ default:
+ break;
+ }
+}
+
+static void
+gtk_progress_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkProgress *progress;
+
+ progress = GTK_PROGRESS (object);
+
+ switch (arg_id)
+ {
+ case ARG_ACTIVITY_MODE:
+ GTK_VALUE_BOOL (*arg) = (progress->activity_mode != 0);
+ break;
+ case ARG_SHOW_TEXT:
+ GTK_VALUE_BOOL (*arg) = (progress->show_text != 0);
+ break;
+ case ARG_TEXT_XALIGN:
+ GTK_VALUE_FLOAT (*arg) = progress->x_align;
+ break;
+ case ARG_TEXT_YALIGN:
+ GTK_VALUE_FLOAT (*arg) = progress->y_align;
+ break;
+ default:
+ arg->type = GTK_TYPE_INVALID;
+ break;
+ }
+}
+static void
+gtk_progress_init (GtkProgress *progress)
+{
+ progress->adjustment = NULL;
progress->offscreen_pixmap = NULL;
progress->format = g_strdup ("%P %%");
progress->x_align = 0.5;
gtk_progress_create_pixmap (progress);
}
+static void
+gtk_progress_destroy (GtkObject *object)
+{
+ GtkProgress *progress;
+
+ g_return_if_fail (object != NULL);
+ g_return_if_fail (GTK_IS_PROGRESS (object));
+
+ progress = GTK_PROGRESS (object);
+
+ if (progress->adjustment)
+ gtk_signal_disconnect_by_data (GTK_OBJECT (progress->adjustment),
+ progress);
+
+ GTK_OBJECT_CLASS (parent_class)->destroy (object);
+}
+
static void
gtk_progress_finalize (GtkObject *object)
{
progress = GTK_PROGRESS (object);
- gtk_object_unref (GTK_OBJECT (GTK_PROGRESS (object)->adjustment));
+ if (progress->adjustment)
+ gtk_object_unref (GTK_OBJECT (GTK_PROGRESS (object)->adjustment));
if (progress->offscreen_pixmap)
gdk_pixmap_unref (progress->offscreen_pixmap);
{
g_return_if_fail (progress != NULL);
g_return_if_fail (GTK_IS_PROGRESS (progress));
+ if (adjustment)
+ g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
+ else
+ adjustment = (GtkAdjustment*) gtk_object_new (GTK_TYPE_ADJUSTMENT, NULL);
if (progress->adjustment != adjustment)
{
#endif /* __cplusplus */
-#define GTK_PROGRESS(obj) GTK_CHECK_CAST (obj, gtk_progress_get_type (), GtkProgress)
-#define GTK_PROGRESS_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_progress_get_type (), GtkProgressClass)
-#define GTK_IS_PROGRESS(obj) GTK_CHECK_TYPE (obj, gtk_progress_get_type ())
+#define GTK_TYPE_PROGRESS (gtk_progress_get_type ())
+#define GTK_PROGRESS(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_PROGRESS, GtkProgress))
+#define GTK_PROGRESS_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_PROGRESS, GtkProgressClass))
+#define GTK_IS_PROGRESS(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_PROGRESS))
+#define GTK_IS_PROGRESS_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_PROGRESS))
typedef struct _GtkProgress GtkProgress;
};
-guint gtk_progress_get_type (void);
+GtkType gtk_progress_get_type (void);
void gtk_progress_set_show_text (GtkProgress *progress,
gint show_text);
void gtk_progress_set_text_alignment (GtkProgress *progress,
gfloat gtk_progress_get_value (GtkProgress *progress);
void gtk_progress_set_activity_mode (GtkProgress *progress,
guint activity_mode);
-gchar * gtk_progress_get_current_text (GtkProgress *progress);
-gchar * gtk_progress_get_text_from_value (GtkProgress *progress,
+gchar* gtk_progress_get_current_text (GtkProgress *progress);
+gchar* gtk_progress_get_text_from_value (GtkProgress *progress,
gfloat value);
gfloat gtk_progress_get_current_percentage (GtkProgress *progress);
gfloat gtk_progress_get_percentage_from_value (GtkProgress *progress,
#define MAX_TEXT_LENGTH 80
#define TEXT_SPACING 2
+enum {
+ ARG_0,
+ ARG_ADJUSTMENT,
+ ARG_ORIENTATION,
+ ARG_BAR_STYLE,
+ ARG_ACTIVITY_STEP,
+ ARG_ACTIVITY_BLOCKS,
+ ARG_DISCRETE_BLOCKS
+};
static void gtk_progress_bar_class_init (GtkProgressBarClass *klass);
static void gtk_progress_bar_init (GtkProgressBar *pbar);
+static void gtk_progress_bar_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
+static void gtk_progress_bar_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
static void gtk_progress_bar_size_request (GtkWidget *widget,
GtkRequisition *requisition);
static void gtk_progress_bar_real_update (GtkProgress *progress);
static void gtk_progress_bar_act_mode_enter (GtkProgress *progress);
-guint
+GtkType
gtk_progress_bar_get_type (void)
{
- static guint progress_bar_type = 0;
+ static GtkType progress_bar_type = 0;
if (!progress_bar_type)
{
(GtkClassInitFunc) NULL
};
- progress_bar_type = gtk_type_unique (gtk_progress_get_type (),
- &progress_bar_info);
+ progress_bar_type = gtk_type_unique (GTK_TYPE_PROGRESS, &progress_bar_info);
}
return progress_bar_type;
static void
gtk_progress_bar_class_init (GtkProgressBarClass *class)
{
+ GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
GtkProgressClass *progress_class;
-
+
+ object_class = (GtkObjectClass *) class;
widget_class = (GtkWidgetClass *) class;
progress_class = (GtkProgressClass *) class;
+
+ gtk_object_add_arg_type ("GtkProgressBar::adjustment",
+ GTK_TYPE_ADJUSTMENT,
+ GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
+ ARG_ADJUSTMENT);
+ gtk_object_add_arg_type ("GtkProgressBar::orientation",
+ GTK_TYPE_PROGRESS_BAR_ORIENTATION,
+ GTK_ARG_READWRITE,
+ ARG_ORIENTATION);
+ gtk_object_add_arg_type ("GtkProgressBar::bar_style",
+ GTK_TYPE_PROGRESS_BAR_STYLE,
+ GTK_ARG_READWRITE,
+ ARG_BAR_STYLE);
+ gtk_object_add_arg_type ("GtkProgressBar::activity_step",
+ GTK_TYPE_UINT,
+ GTK_ARG_READWRITE,
+ ARG_ACTIVITY_STEP);
+ gtk_object_add_arg_type ("GtkProgressBar::activity_blocks",
+ GTK_TYPE_UINT,
+ GTK_ARG_READWRITE,
+ ARG_ACTIVITY_BLOCKS);
+ gtk_object_add_arg_type ("GtkProgressBar::discrete_blocks",
+ GTK_TYPE_UINT,
+ GTK_ARG_READWRITE,
+ ARG_DISCRETE_BLOCKS);
+
+ object_class->set_arg = gtk_progress_bar_set_arg;
+ object_class->get_arg = gtk_progress_bar_get_arg;
widget_class->size_request = gtk_progress_bar_size_request;
static void
gtk_progress_bar_init (GtkProgressBar *pbar)
{
- GTK_WIDGET_SET_FLAGS (pbar, GTK_BASIC);
-
pbar->bar_style = GTK_PROGRESS_CONTINUOUS;
pbar->blocks = 10;
pbar->in_block = -1;
pbar->activity_blocks = 5;
}
+static void
+gtk_progress_bar_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkProgressBar *pbar;
+
+ pbar = GTK_PROGRESS_BAR (object);
-GtkWidget *
-gtk_progress_bar_new (void)
+ switch (arg_id)
+ {
+ case ARG_ADJUSTMENT:
+ gtk_progress_set_adjustment (GTK_PROGRESS (pbar), GTK_VALUE_POINTER (*arg));
+ break;
+ case ARG_ORIENTATION:
+ gtk_progress_bar_set_orientation (pbar, GTK_VALUE_ENUM (*arg));
+ break;
+ case ARG_BAR_STYLE:
+ gtk_progress_bar_set_bar_style (pbar, GTK_VALUE_ENUM (*arg));
+ break;
+ case ARG_ACTIVITY_STEP:
+ gtk_progress_bar_set_activity_step (pbar, GTK_VALUE_UINT (*arg));
+ break;
+ case ARG_ACTIVITY_BLOCKS:
+ gtk_progress_bar_set_activity_blocks (pbar, GTK_VALUE_UINT (*arg));
+ break;
+ case ARG_DISCRETE_BLOCKS:
+ gtk_progress_bar_set_discrete_blocks (pbar, GTK_VALUE_UINT (*arg));
+ break;
+ default:
+ break;
+ }
+}
+
+static void
+gtk_progress_bar_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
{
GtkProgressBar *pbar;
- pbar = gtk_type_new (gtk_progress_bar_get_type ());
+ pbar = GTK_PROGRESS_BAR (object);
+
+ switch (arg_id)
+ {
+ case ARG_ADJUSTMENT:
+ GTK_VALUE_POINTER (*arg) = GTK_PROGRESS (pbar)->adjustment;
+ break;
+ case ARG_ORIENTATION:
+ GTK_VALUE_ENUM (*arg) = pbar->orientation;
+ break;
+ case ARG_BAR_STYLE:
+ GTK_VALUE_ENUM (*arg) = pbar->bar_style;
+ break;
+ case ARG_ACTIVITY_STEP:
+ GTK_VALUE_UINT (*arg) = pbar->activity_step;
+ break;
+ case ARG_ACTIVITY_BLOCKS:
+ GTK_VALUE_UINT (*arg) = pbar->activity_blocks;
+ break;
+ case ARG_DISCRETE_BLOCKS:
+ GTK_VALUE_UINT (*arg) = pbar->blocks;
+ break;
+ default:
+ arg->type = GTK_TYPE_INVALID;
+ break;
+ }
+}
+
+GtkWidget*
+gtk_progress_bar_new (void)
+{
+ GtkWidget *pbar;
- gtk_progress_bar_construct (pbar, NULL);
+ pbar = gtk_widget_new (GTK_TYPE_PROGRESS_BAR, NULL);
- return GTK_WIDGET (pbar);
+ return pbar;
}
-GtkWidget *
+GtkWidget*
gtk_progress_bar_new_with_adjustment (GtkAdjustment *adjustment)
{
- GtkProgressBar *pbar;
+ GtkWidget *pbar;
- pbar = gtk_type_new (gtk_progress_bar_get_type ());
+ g_return_val_if_fail (adjustment != NULL, NULL);
+ g_return_val_if_fail (GTK_IS_ADJUSTMENT (adjustment), NULL);
- gtk_progress_bar_construct (pbar, adjustment);
+ pbar = gtk_widget_new (GTK_TYPE_PROGRESS_BAR,
+ "adjustment", adjustment,
+ NULL);
- return GTK_WIDGET (pbar);
+ return pbar;
}
void
g_return_if_fail (pbar != NULL);
g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
- if (!adjustment)
- adjustment = (GtkAdjustment *) gtk_adjustment_new (0, 0, 100, 0, 0, 0);
+ g_message ("gtk_progress_bar_construct() is deprecated");
gtk_progress_set_adjustment (GTK_PROGRESS (pbar), adjustment);
}
#endif /* __cplusplus */
-#define GTK_PROGRESS_BAR(obj) GTK_CHECK_CAST (obj, gtk_progress_bar_get_type (), GtkProgressBar)
-#define GTK_PROGRESS_BAR_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_progress_bar_get_type (), GtkProgressBarClass)
-#define GTK_IS_PROGRESS_BAR(obj) GTK_CHECK_TYPE (obj, gtk_progress_bar_get_type ())
+#define GTK_TYPE_PROGRESS_BAR (gtk_progress_bar_get_type ())
+#define GTK_PROGRESS_BAR(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_PROGRESS_BAR, GtkProgressBar))
+#define GTK_PROGRESS_BAR_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_PROGRESS_BAR, GtkProgressBarClass))
+#define GTK_IS_PROGRESS_BAR(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_PROGRESS_BAR))
+#define GTK_IS_PROGRESS_BAR_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_PROGRESS_BAR))
typedef struct _GtkProgressBar GtkProgressBar;
};
-guint gtk_progress_bar_get_type (void);
+GtkType gtk_progress_bar_get_type (void);
GtkWidget* gtk_progress_bar_new (void);
GtkWidget* gtk_progress_bar_new_with_adjustment (GtkAdjustment *adjustment);
-void gtk_progress_bar_construct (GtkProgressBar *pbar,
- GtkAdjustment *adjustment);
void gtk_progress_bar_set_bar_style (GtkProgressBar *pbar,
GtkProgressBarStyle style);
void gtk_progress_bar_set_discrete_blocks (GtkProgressBar *pbar,
void gtk_progress_bar_update (GtkProgressBar *pbar,
gfloat percentage);
+/* deprecated */
+void gtk_progress_bar_construct (GtkProgressBar *pbar,
+ GtkAdjustment *adjustment);
+
#ifdef __cplusplus
}
#define RANGE_CLASS(w) GTK_RANGE_CLASS (GTK_OBJECT (w)->klass)
+enum {
+ ARG_0,
+ ARG_UPDATE_POLICY
+};
static void gtk_range_class_init (GtkRangeClass *klass);
static void gtk_range_init (GtkRange *range);
+static void gtk_range_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
+static void gtk_range_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
+static void gtk_range_destroy (GtkObject *object);
static void gtk_range_finalize (GtkObject *object);
static void gtk_range_draw (GtkWidget *widget,
GdkRectangle *area);
static GtkWidgetClass *parent_class = NULL;
-guint
+GtkType
gtk_range_get_type (void)
{
- static guint range_type = 0;
+ static GtkType range_type = 0;
if (!range_type)
{
(GtkClassInitFunc) NULL,
};
- range_type = gtk_type_unique (gtk_widget_get_type (), &range_info);
+ range_type = gtk_type_unique (GTK_TYPE_WIDGET, &range_info);
}
return range_type;
object_class = (GtkObjectClass*) class;
widget_class = (GtkWidgetClass*) class;
- parent_class = gtk_type_class (gtk_widget_get_type ());
+ parent_class = gtk_type_class (GTK_TYPE_WIDGET);
+ gtk_object_add_arg_type ("GtkRange::update_policy",
+ GTK_TYPE_UPDATE_TYPE,
+ GTK_ARG_READWRITE,
+ ARG_UPDATE_POLICY);
+
+ object_class->set_arg = gtk_range_set_arg;
+ object_class->get_arg = gtk_range_get_arg;
+ object_class->destroy = gtk_range_destroy;
object_class->finalize = gtk_range_finalize;
widget_class->draw = gtk_range_draw;
class->timer = gtk_real_range_timer;
}
+static void
+gtk_range_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkRange *range;
+
+ range = GTK_RANGE (object);
+
+ switch (arg_id)
+ {
+ case ARG_UPDATE_POLICY:
+ gtk_range_set_update_policy (range, GTK_VALUE_ENUM (*arg));
+ break;
+ default:
+ break;
+ }
+}
+
+static void
+gtk_range_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkRange *range;
+
+ range = GTK_RANGE (object);
+
+ switch (arg_id)
+ {
+ case ARG_UPDATE_POLICY:
+ GTK_VALUE_ENUM (*arg) = range->policy;
+ break;
+ default:
+ arg->type = GTK_TYPE_INVALID;
+ break;
+ }
+}
+
static void
gtk_range_init (GtkRange *range)
{
{
g_return_if_fail (range != NULL);
g_return_if_fail (GTK_IS_RANGE (range));
+
+ if (!adjustment)
+ adjustment = (GtkAdjustment*) gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
+ else
+ g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
if (range->adjustment != adjustment)
{
(gpointer) range);
gtk_object_unref (GTK_OBJECT (range->adjustment));
}
+
range->adjustment = adjustment;
- if (adjustment)
- {
- gtk_object_ref (GTK_OBJECT (adjustment));
- gtk_object_sink (GTK_OBJECT (adjustment));
-
- gtk_signal_connect (GTK_OBJECT (adjustment), "changed",
- (GtkSignalFunc) gtk_range_adjustment_changed,
- (gpointer) range);
- gtk_signal_connect (GTK_OBJECT (adjustment), "value_changed",
- (GtkSignalFunc) gtk_range_adjustment_value_changed,
- (gpointer) range);
-
- range->old_value = adjustment->value;
- range->old_lower = adjustment->lower;
- range->old_upper = adjustment->upper;
- range->old_page_size = adjustment->page_size;
-
- gtk_range_adjustment_changed (adjustment, (gpointer) range);
- }
+ gtk_object_ref (GTK_OBJECT (adjustment));
+ gtk_object_sink (GTK_OBJECT (adjustment));
+
+ gtk_signal_connect (GTK_OBJECT (adjustment), "changed",
+ (GtkSignalFunc) gtk_range_adjustment_changed,
+ (gpointer) range);
+ gtk_signal_connect (GTK_OBJECT (adjustment), "value_changed",
+ (GtkSignalFunc) gtk_range_adjustment_value_changed,
+ (gpointer) range);
+
+ range->old_value = adjustment->value;
+ range->old_lower = adjustment->lower;
+ range->old_upper = adjustment->upper;
+ range->old_page_size = adjustment->page_size;
+
+ gtk_range_adjustment_changed (adjustment, (gpointer) range);
}
}
}
+static void
+gtk_range_destroy (GtkObject *object)
+{
+ GtkRange *range;
+
+ g_return_if_fail (object != NULL);
+ g_return_if_fail (GTK_IS_RANGE (object));
+
+ range = GTK_RANGE (object);
+
+ if (range->adjustment)
+ gtk_signal_disconnect_by_data (GTK_OBJECT (range->adjustment),
+ (gpointer) range);
+
+ (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
+}
+
static void
gtk_range_finalize (GtkObject *object)
{
#endif /* __cplusplus */
-#define GTK_RANGE(obj) GTK_CHECK_CAST (obj, gtk_range_get_type (), GtkRange)
-#define GTK_RANGE_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_range_get_type (), GtkRangeClass)
-#define GTK_IS_RANGE(obj) GTK_CHECK_TYPE (obj, gtk_range_get_type ())
+#define GTK_TYPE_RANGE (gtk_range_get_type ())
+#define GTK_RANGE(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_RANGE, GtkRange))
+#define GTK_RANGE_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_RANGE, GtkRangeClass))
+#define GTK_IS_RANGE(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_RANGE))
+#define GTK_IS_RANGE_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_RANGE))
typedef struct _GtkRange GtkRange;
};
-guint gtk_range_get_type (void);
+GtkType gtk_range_get_type (void);
GtkAdjustment* gtk_range_get_adjustment (GtkRange *range);
void gtk_range_set_update_policy (GtkRange *range,
GtkUpdateType policy);
static GtkRangeClass *parent_class = NULL;
-guint
+GtkType
gtk_scale_get_type (void)
{
- static guint scale_type = 0;
+ static GtkType scale_type = 0;
if (!scale_type)
{
(GtkClassInitFunc) NULL,
};
- scale_type = gtk_type_unique (gtk_range_get_type (), &scale_info);
+ scale_type = gtk_type_unique (GTK_TYPE_RANGE, &scale_info);
}
return scale_type;
range_class = (GtkRangeClass*) class;
widget_class = (GtkWidgetClass*) class;
- parent_class = gtk_type_class (gtk_range_get_type ());
+ parent_class = gtk_type_class (GTK_TYPE_RANGE);
widget_class->map = gtk_scale_map;
widget_class->unmap = gtk_scale_unmap;
#endif /* __cplusplus */
-#define GTK_SCALE(obj) GTK_CHECK_CAST (obj, gtk_scale_get_type (), GtkScale)
-#define GTK_SCALE_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_scale_get_type (), GtkScaleClass)
-#define GTK_IS_SCALE(obj) GTK_CHECK_TYPE (obj, gtk_scale_get_type ())
+#define GTK_TYPE_SCALE (gtk_scale_get_type ())
+#define GTK_SCALE(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_SCALE, GtkScale))
+#define GTK_SCALE_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_SCALE, GtkScaleClass))
+#define GTK_IS_SCALE(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_SCALE))
+#define GTK_IS_SCALE_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SCALE))
typedef struct _GtkScale GtkScale;
gint slider_length;
gint value_spacing;
-
+
void (* draw_value) (GtkScale *scale);
};
-guint gtk_scale_get_type (void);
-void gtk_scale_set_digits (GtkScale *scale,
- gint digits);
-void gtk_scale_set_draw_value (GtkScale *scale,
- gint draw_value);
-void gtk_scale_set_value_pos (GtkScale *scale,
- GtkPositionType pos);
-gint gtk_scale_value_width (GtkScale *scale);
+GtkType gtk_scale_get_type (void);
+void gtk_scale_set_digits (GtkScale *scale,
+ gint digits);
+void gtk_scale_set_draw_value (GtkScale *scale,
+ gint draw_value);
+void gtk_scale_set_value_pos (GtkScale *scale,
+ GtkPositionType pos);
+gint gtk_scale_value_width (GtkScale *scale);
-void gtk_scale_draw_value (GtkScale *scale);
+void gtk_scale_draw_value (GtkScale *scale);
#ifdef __cplusplus
static void gtk_scrollbar_class_init (GtkScrollbarClass *klass);
static void gtk_scrollbar_init (GtkScrollbar *scrollbar);
-guint
+GtkType
gtk_scrollbar_get_type (void)
{
- static guint scrollbar_type = 0;
+ static GtkType scrollbar_type = 0;
if (!scrollbar_type)
{
(GtkClassInitFunc) NULL,
};
- scrollbar_type = gtk_type_unique (gtk_range_get_type (), &scrollbar_info);
+ scrollbar_type = gtk_type_unique (GTK_TYPE_RANGE, &scrollbar_info);
}
return scrollbar_type;
#endif /* __cplusplus */
-#define GTK_SCROLLBAR(obj) GTK_CHECK_CAST (obj, gtk_scrollbar_get_type (), GtkScrollbar)
-#define GTK_SCROLLBAR_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_scrollbar_get_type (), GtkScrollbarClass)
-#define GTK_IS_SCROLLBAR(obj) GTK_CHECK_TYPE (obj, gtk_scrollbar_get_type ())
+#define GTK_TYPE_SCROLLBAR (gtk_scrollbar_get_type ())
+#define GTK_SCROLLBAR(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_SCROLLBAR, GtkScrollbar))
+#define GTK_SCROLLBAR_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_SCROLLBAR, GtkScrollbarClass))
+#define GTK_IS_SCROLLBAR(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_SCROLLBAR))
+#define GTK_IS_SCROLLBAR_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SCROLLBAR))
typedef struct _GtkScrollbar GtkScrollbar;
};
-guint gtk_scrollbar_get_type (void);
+GtkType gtk_scrollbar_get_type (void);
#ifdef __cplusplus
enum {
ARG_0,
- ARG_VIEWPORT,
+ ARG_HADJUSTMENT,
+ ARG_VADJUSTMENT,
ARG_HSCROLLBAR_POLICY,
ARG_VSCROLLBAR_POLICY,
ARG_WINDOW_PLACEMENT
gboolean include_internals,
GtkCallback callback,
gpointer callback_data);
-static void gtk_scrolled_window_viewport_allocate (GtkWidget *widget,
+static void gtk_scrolled_window_relative_allocation(GtkWidget *widget,
GtkAllocation *allocation);
static void gtk_scrolled_window_adjustment_changed (GtkAdjustment *adjustment,
gpointer data);
container_class = (GtkContainerClass*) class;
parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
- gtk_object_add_arg_type ("GtkScrolledWindow::viewport",
- GTK_TYPE_VIEWPORT,
+ gtk_object_add_arg_type ("GtkScrolledWindow::hadjustment",
+ GTK_TYPE_ADJUSTMENT,
GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
- ARG_VIEWPORT);
+ ARG_HADJUSTMENT);
+ gtk_object_add_arg_type ("GtkScrolledWindow::vadjustment",
+ GTK_TYPE_ADJUSTMENT,
+ GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
+ ARG_VADJUSTMENT);
gtk_object_add_arg_type ("GtkScrolledWindow::hscrollbar_policy",
GTK_TYPE_POLICY_TYPE,
GTK_ARG_READWRITE,
switch (arg_id)
{
- GtkWidget *viewport;
-
- case ARG_VIEWPORT:
- viewport = GTK_VALUE_POINTER (*arg);
- gtk_container_add (GTK_CONTAINER (scrolled_window), viewport);
+ case ARG_HADJUSTMENT:
+ gtk_scrolled_window_set_hadjustment (scrolled_window, GTK_VALUE_POINTER (*arg));
+ break;
+ case ARG_VADJUSTMENT:
+ gtk_scrolled_window_set_vadjustment (scrolled_window, GTK_VALUE_POINTER (*arg));
+ break;
case ARG_HSCROLLBAR_POLICY:
gtk_scrolled_window_set_policy (scrolled_window,
GTK_VALUE_ENUM (*arg),
switch (arg_id)
{
- case ARG_VIEWPORT:
- GTK_VALUE_POINTER (*arg) = scrolled_window->viewport;
+ case ARG_HADJUSTMENT:
+ GTK_VALUE_POINTER (*arg) = gtk_scrolled_window_get_hadjustment (scrolled_window);
+ break;
+ case ARG_VADJUSTMENT:
+ GTK_VALUE_POINTER (*arg) = gtk_scrolled_window_get_vadjustment (scrolled_window);
break;
case ARG_HSCROLLBAR_POLICY:
GTK_VALUE_ENUM (*arg) = scrolled_window->hscrollbar_policy;
gtk_container_set_resize_mode (GTK_CONTAINER (scrolled_window), GTK_RESIZE_QUEUE);
+ scrolled_window->child = NULL;
scrolled_window->hscrollbar = NULL;
scrolled_window->vscrollbar = NULL;
scrolled_window->hscrollbar_policy = GTK_POLICY_ALWAYS;
scrolled_window->vscrollbar_policy = GTK_POLICY_ALWAYS;
+ scrolled_window->hscrollbar_visible = FALSE;
+ scrolled_window->vscrollbar_visible = FALSE;
scrolled_window->window_placement = GTK_CORNER_TOP_LEFT;
- scrolled_window->autogenerated_viewport = FALSE;
}
GtkWidget*
{
GtkWidget *scrolled_window;
- scrolled_window = gtk_type_new (GTK_TYPE_SCROLLED_WINDOW);
+ if (hadjustment)
+ g_return_val_if_fail (GTK_IS_ADJUSTMENT (hadjustment), NULL);
+
+ if (vadjustment)
+ g_return_val_if_fail (GTK_IS_ADJUSTMENT (vadjustment), NULL);
- gtk_scrolled_window_construct (GTK_SCROLLED_WINDOW (scrolled_window), hadjustment, vadjustment);
+ scrolled_window = gtk_widget_new (GTK_TYPE_SCROLLED_WINDOW,
+ "hadjustment", hadjustment,
+ "vadjustment", vadjustment,
+ NULL);
return scrolled_window;
}
gtk_scrolled_window_construct (GtkScrolledWindow *scrolled_window,
GtkAdjustment *hadjustment,
GtkAdjustment *vadjustment)
+{
+ g_message ("gtk_scrolled_window_construct() is deprecated");
+ gtk_scrolled_window_set_hadjustment (scrolled_window, hadjustment);
+ gtk_scrolled_window_set_vadjustment (scrolled_window, vadjustment);
+ gtk_object_default_construct (GTK_OBJECT (scrolled_window));
+}
+
+void
+gtk_scrolled_window_set_hadjustment (GtkScrolledWindow *scrolled_window,
+ GtkAdjustment *hadjustment)
{
g_return_if_fail (scrolled_window != NULL);
g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
- g_return_if_fail (scrolled_window->hscrollbar == NULL);
- g_return_if_fail (scrolled_window->vscrollbar == NULL);
+ if (hadjustment)
+ g_return_if_fail (GTK_IS_ADJUSTMENT (hadjustment));
+ else
+ hadjustment = (GtkAdjustment*) gtk_object_new (GTK_TYPE_ADJUSTMENT, NULL);
- scrolled_window->hscrollbar = gtk_hscrollbar_new (hadjustment);
- scrolled_window->vscrollbar = gtk_vscrollbar_new (vadjustment);
+ if (!scrolled_window->hscrollbar)
+ {
+ gtk_widget_push_composite_child ();
+ scrolled_window->hscrollbar = gtk_hscrollbar_new (hadjustment);
+ gtk_widget_pop_composite_child ();
- hadjustment =
- gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar));
- vadjustment =
- gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar));
+ gtk_widget_set_parent (scrolled_window->hscrollbar, GTK_WIDGET (scrolled_window));
+ gtk_widget_ref (scrolled_window->hscrollbar);
+ gtk_widget_show (scrolled_window->hscrollbar);
+ }
+ else
+ {
+ GtkAdjustment *old_adjustment;
+
+ old_adjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar));
+ if (old_adjustment == hadjustment)
+ return;
+
+ gtk_signal_disconnect_by_func (GTK_OBJECT (old_adjustment),
+ GTK_SIGNAL_FUNC (gtk_scrolled_window_adjustment_changed),
+ scrolled_window);
+ gtk_range_set_adjustment (GTK_RANGE (scrolled_window->hscrollbar),
+ hadjustment);
+ }
+ hadjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar));
+ gtk_signal_connect (GTK_OBJECT (hadjustment),
+ "changed",
+ GTK_SIGNAL_FUNC (gtk_scrolled_window_adjustment_changed),
+ scrolled_window);
+ gtk_scrolled_window_adjustment_changed (hadjustment, scrolled_window);
+
+ if (scrolled_window->child)
+ gtk_widget_scroll_adjustements (scrolled_window->child,
+ gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)),
+ gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar)));
+}
- gtk_signal_connect (GTK_OBJECT (hadjustment), "changed",
- (GtkSignalFunc) gtk_scrolled_window_adjustment_changed,
- (gpointer) scrolled_window);
- gtk_signal_connect (GTK_OBJECT (vadjustment), "changed",
- (GtkSignalFunc) gtk_scrolled_window_adjustment_changed,
- (gpointer) scrolled_window);
+void
+gtk_scrolled_window_set_vadjustment (GtkScrolledWindow *scrolled_window,
+ GtkAdjustment *vadjustment)
+{
+ g_return_if_fail (scrolled_window != NULL);
+ g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
+ if (vadjustment)
+ g_return_if_fail (GTK_IS_ADJUSTMENT (vadjustment));
+ else
+ vadjustment = (GtkAdjustment*) gtk_object_new (GTK_TYPE_ADJUSTMENT, NULL);
- gtk_widget_set_parent (scrolled_window->hscrollbar, GTK_WIDGET (scrolled_window));
- gtk_widget_set_parent (scrolled_window->vscrollbar, GTK_WIDGET (scrolled_window));
+ if (!scrolled_window->vscrollbar)
+ {
+ gtk_widget_push_composite_child ();
+ scrolled_window->vscrollbar = gtk_vscrollbar_new (vadjustment);
+ gtk_widget_pop_composite_child ();
- gtk_widget_show (scrolled_window->hscrollbar);
- gtk_widget_show (scrolled_window->vscrollbar);
-
- gtk_widget_ref (scrolled_window->hscrollbar);
- gtk_widget_ref (scrolled_window->vscrollbar);
+ gtk_widget_set_parent (scrolled_window->vscrollbar, GTK_WIDGET (scrolled_window));
+ gtk_widget_ref (scrolled_window->vscrollbar);
+ gtk_widget_show (scrolled_window->vscrollbar);
+ }
+ else
+ {
+ GtkAdjustment *old_adjustment;
+
+ old_adjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar));
+ if (old_adjustment == vadjustment)
+ return;
+
+ gtk_signal_disconnect_by_func (GTK_OBJECT (old_adjustment),
+ GTK_SIGNAL_FUNC (gtk_scrolled_window_adjustment_changed),
+ scrolled_window);
+ gtk_range_set_adjustment (GTK_RANGE (scrolled_window->vscrollbar),
+ vadjustment);
+ }
+ vadjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar));
+ gtk_signal_connect (GTK_OBJECT (vadjustment),
+ "changed",
+ GTK_SIGNAL_FUNC (gtk_scrolled_window_adjustment_changed),
+ scrolled_window);
+ gtk_scrolled_window_adjustment_changed (vadjustment, scrolled_window);
+
+ if (scrolled_window->child)
+ gtk_widget_scroll_adjustements (scrolled_window->child,
+ gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)),
+ gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar)));
}
GtkAdjustment*
g_return_val_if_fail (scrolled_window != NULL, NULL);
g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), NULL);
- return gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar));
+ return (scrolled_window->hscrollbar ?
+ gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)) :
+ NULL);
}
GtkAdjustment*
g_return_val_if_fail (scrolled_window != NULL, NULL);
g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), NULL);
- return gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar));
+ return (scrolled_window->vscrollbar ?
+ gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar)) :
+ NULL);
}
void
scrolled_window->hscrollbar_policy = hscrollbar_policy;
scrolled_window->vscrollbar_policy = vscrollbar_policy;
- if (GTK_WIDGET (scrolled_window)->parent)
- gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
+ gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
}
}
{
scrolled_window->window_placement = window_placement;
- if (GTK_WIDGET (scrolled_window)->parent)
- gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
+ gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
}
}
scrolled_window = GTK_SCROLLED_WINDOW (object);
- gtk_widget_destroy (scrolled_window->viewport);
+ gtk_widget_unparent (scrolled_window->hscrollbar);
+ gtk_widget_unparent (scrolled_window->vscrollbar);
gtk_widget_destroy (scrolled_window->hscrollbar);
gtk_widget_destroy (scrolled_window->vscrollbar);
GtkScrolledWindow *scrolled_window;
scrolled_window = GTK_SCROLLED_WINDOW (object);
- gtk_widget_unref (scrolled_window->viewport);
+
gtk_widget_unref (scrolled_window->hscrollbar);
gtk_widget_unref (scrolled_window->vscrollbar);
static void
gtk_scrolled_window_map (GtkWidget *widget)
{
- GtkScrolledWindow *scrolled_window;
-
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_SCROLLED_WINDOW (widget));
if (!GTK_WIDGET_MAPPED (widget))
{
- GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
+ GtkScrolledWindow *scrolled_window;
+
scrolled_window = GTK_SCROLLED_WINDOW (widget);
+ GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
- if (scrolled_window->viewport &&
- GTK_WIDGET_VISIBLE (scrolled_window->viewport) &&
- !GTK_WIDGET_MAPPED (scrolled_window->viewport))
- gtk_widget_map (scrolled_window->viewport);
+ if (scrolled_window->child &&
+ GTK_WIDGET_VISIBLE (scrolled_window->child) &&
+ !GTK_WIDGET_MAPPED (scrolled_window->child))
+ gtk_widget_map (scrolled_window->child);
if (GTK_WIDGET_VISIBLE (scrolled_window->hscrollbar) &&
!GTK_WIDGET_MAPPED (scrolled_window->hscrollbar))
if (GTK_WIDGET_VISIBLE (scrolled_window->vscrollbar) &&
!GTK_WIDGET_MAPPED (scrolled_window->vscrollbar))
gtk_widget_map (scrolled_window->vscrollbar);
+
+ gtk_widget_queue_draw (widget);
}
}
static void
gtk_scrolled_window_unmap (GtkWidget *widget)
{
- GtkScrolledWindow *scrolled_window;
-
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_SCROLLED_WINDOW (widget));
if (GTK_WIDGET_MAPPED (widget))
{
- GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
+ GtkScrolledWindow *scrolled_window;
+
scrolled_window = GTK_SCROLLED_WINDOW (widget);
+ GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
- if (scrolled_window->viewport &&
- GTK_WIDGET_MAPPED (scrolled_window->viewport))
- gtk_widget_unmap (scrolled_window->viewport);
+ if (scrolled_window->child &&
+ GTK_WIDGET_VISIBLE (scrolled_window->child) &&
+ GTK_WIDGET_MAPPED (scrolled_window->child))
+ gtk_widget_unmap (scrolled_window->child);
if (GTK_WIDGET_MAPPED (scrolled_window->hscrollbar))
gtk_widget_unmap (scrolled_window->hscrollbar);
if (GTK_WIDGET_MAPPED (scrolled_window->vscrollbar))
gtk_widget_unmap (scrolled_window->vscrollbar);
+
+ gtk_widget_queue_clear (widget);
}
}
gtk_scrolled_window_draw (GtkWidget *widget,
GdkRectangle *area)
{
- GtkScrolledWindow *scrolled_window;
- GdkRectangle child_area;
-
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_SCROLLED_WINDOW (widget));
g_return_if_fail (area != NULL);
-
+
if (GTK_WIDGET_DRAWABLE (widget))
{
+ GtkScrolledWindow *scrolled_window;
+ GdkRectangle child_area;
+
scrolled_window = GTK_SCROLLED_WINDOW (widget);
+
+ if (scrolled_window->child && GTK_WIDGET_VISIBLE (scrolled_window->child) &&
+ gtk_widget_intersect (scrolled_window->child, area, &child_area))
+ gtk_widget_draw (scrolled_window->child, &child_area);
- if (scrolled_window->viewport &&
- gtk_widget_intersect (scrolled_window->viewport, area, &child_area))
- gtk_widget_draw (scrolled_window->viewport, &child_area);
-
- if (gtk_widget_intersect (scrolled_window->hscrollbar, area, &child_area))
+ if (GTK_WIDGET_VISIBLE (scrolled_window->hscrollbar) &&
+ gtk_widget_intersect (scrolled_window->hscrollbar, area, &child_area))
gtk_widget_draw (scrolled_window->hscrollbar, &child_area);
- if (gtk_widget_intersect (scrolled_window->vscrollbar, area, &child_area))
+ if (GTK_WIDGET_VISIBLE (scrolled_window->vscrollbar) &&
+ gtk_widget_intersect (scrolled_window->vscrollbar, area, &child_area))
gtk_widget_draw (scrolled_window->vscrollbar, &child_area);
}
}
+static void
+gtk_scrolled_window_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data)
+{
+ GtkScrolledWindow *scrolled_window;
+
+ g_return_if_fail (container != NULL);
+ g_return_if_fail (GTK_IS_SCROLLED_WINDOW (container));
+ g_return_if_fail (callback != NULL);
+
+ scrolled_window = GTK_SCROLLED_WINDOW (container);
+
+ if (scrolled_window->child)
+ callback (scrolled_window->child, callback_data);
+ if (include_internals)
+ {
+ callback (scrolled_window->vscrollbar, callback_data);
+ callback (scrolled_window->hscrollbar, callback_data);
+ }
+}
+
static void
gtk_scrolled_window_size_request (GtkWidget *widget,
GtkRequisition *requisition)
requisition->width = 0;
requisition->height = 0;
- if (scrolled_window->viewport &&
- GTK_WIDGET_VISIBLE (scrolled_window->viewport))
+ if (scrolled_window->child && GTK_WIDGET_VISIBLE (scrolled_window->child))
{
- gtk_widget_size_request (scrolled_window->viewport, &scrolled_window->viewport->requisition);
+ gtk_widget_size_request (scrolled_window->child, &scrolled_window->child->requisition);
- requisition->width += scrolled_window->viewport->requisition.width;
- requisition->height += scrolled_window->viewport->requisition.height;
+ requisition->width += scrolled_window->child->requisition.width;
+ requisition->height += scrolled_window->child->requisition.height;
}
extra_width = 0;
requisition->height += GTK_CONTAINER (widget)->border_width * 2 + extra_height;
}
+static void
+gtk_scrolled_window_relative_allocation (GtkWidget *widget,
+ GtkAllocation *allocation)
+{
+ GtkScrolledWindow *scrolled_window;
+
+ g_return_if_fail (widget != NULL);
+ g_return_if_fail (allocation != NULL);
+
+ scrolled_window = GTK_SCROLLED_WINDOW (widget);
+
+ allocation->x = GTK_CONTAINER (widget)->border_width;
+ allocation->y = GTK_CONTAINER (widget)->border_width;
+ allocation->width = MAX (1, widget->allocation.width - allocation->x * 2);
+ allocation->height = MAX (1, widget->allocation.height - allocation->y * 2);
+
+ if (scrolled_window->vscrollbar_visible)
+ {
+ if (scrolled_window->window_placement == GTK_CORNER_TOP_RIGHT ||
+ scrolled_window->window_placement == GTK_CORNER_BOTTOM_RIGHT)
+ allocation->x += (scrolled_window->vscrollbar->requisition.width +
+ SCROLLBAR_SPACING (scrolled_window));
+
+ allocation->width = MAX (1, allocation->width -
+ (scrolled_window->vscrollbar->requisition.width +
+ SCROLLBAR_SPACING (scrolled_window)));
+ }
+ if (scrolled_window->hscrollbar_visible)
+ {
+ if (scrolled_window->window_placement == GTK_CORNER_BOTTOM_LEFT ||
+ scrolled_window->window_placement == GTK_CORNER_BOTTOM_RIGHT)
+ allocation->y += (scrolled_window->hscrollbar->requisition.height +
+ SCROLLBAR_SPACING (scrolled_window));
+
+ allocation->height = MAX (1, allocation->height -
+ (scrolled_window->hscrollbar->requisition.height +
+ SCROLLBAR_SPACING (scrolled_window)));
+ }
+}
+
static void
gtk_scrolled_window_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
GtkScrolledWindow *scrolled_window;
- GtkAllocation viewport_allocation;
+ GtkAllocation relative_allocation;
GtkAllocation child_allocation;
- guint previous_hvis;
- guint previous_vvis;
- gint count;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_SCROLLED_WINDOW (widget));
if (scrolled_window->vscrollbar_policy == GTK_POLICY_ALWAYS)
scrolled_window->vscrollbar_visible = TRUE;
- if (scrolled_window->viewport &&
- GTK_WIDGET_VISIBLE (scrolled_window->viewport))
+ if (scrolled_window->child && GTK_WIDGET_VISIBLE (scrolled_window->child))
{
- count = 0;
-
- do {
- gtk_scrolled_window_viewport_allocate (widget, &viewport_allocation);
-
- child_allocation.x = viewport_allocation.x + allocation->x;
- child_allocation.y = viewport_allocation.y + allocation->y;
- child_allocation.width = viewport_allocation.width;
- child_allocation.height = viewport_allocation.height;
-
- previous_hvis = scrolled_window->hscrollbar_visible;
- previous_vvis = scrolled_window->vscrollbar_visible;
-
- gtk_widget_size_allocate (scrolled_window->viewport, &child_allocation);
- /* If, after the first iteration, the hscrollbar and the
- * vscrollbar flip visiblity, then we need both.
- */
- if ((count++) &&
- (previous_hvis != scrolled_window->hscrollbar_visible) &&
- (previous_vvis != scrolled_window->vscrollbar_visible))
- {
- scrolled_window->hscrollbar_visible = TRUE;
- scrolled_window->vscrollbar_visible = TRUE;
- break;
- }
-
- count++;
- } while ((previous_hvis != scrolled_window->hscrollbar_visible) ||
- (previous_vvis != scrolled_window->vscrollbar_visible));
+ gboolean previous_hvis;
+ gboolean previous_vvis;
+ guint count = 0;
+
+ do
+ {
+ gtk_scrolled_window_relative_allocation (widget, &relative_allocation);
+
+ child_allocation.x = relative_allocation.x + allocation->x;
+ child_allocation.y = relative_allocation.y + allocation->y;
+ child_allocation.width = relative_allocation.width;
+ child_allocation.height = relative_allocation.height;
+
+ previous_hvis = scrolled_window->hscrollbar_visible;
+ previous_vvis = scrolled_window->vscrollbar_visible;
+
+ gtk_widget_size_allocate (scrolled_window->child, &child_allocation);
+
+ /* If, after the first iteration, the hscrollbar and the
+ * vscrollbar flip visiblity, then we need both.
+ */
+ if (count &&
+ previous_hvis != scrolled_window->hscrollbar_visible &&
+ previous_vvis != scrolled_window->vscrollbar_visible)
+ {
+ scrolled_window->hscrollbar_visible = TRUE;
+ scrolled_window->vscrollbar_visible = TRUE;
+
+ /* a new resize is already queued at this point,
+ * so we will immediatedly get reinvoked
+ */
+ return;
+ }
+
+ count++;
+ }
+ while (previous_hvis != scrolled_window->hscrollbar_visible ||
+ previous_vvis != scrolled_window->vscrollbar_visible);
}
-
+ else
+ gtk_scrolled_window_relative_allocation (widget, &relative_allocation);
+
if (scrolled_window->hscrollbar_visible)
{
if (!GTK_WIDGET_VISIBLE (scrolled_window->hscrollbar))
gtk_widget_show (scrolled_window->hscrollbar);
- child_allocation.x = viewport_allocation.x;
+ child_allocation.x = relative_allocation.x;
if (scrolled_window->window_placement == GTK_CORNER_TOP_LEFT ||
scrolled_window->window_placement == GTK_CORNER_TOP_RIGHT)
- child_allocation.y = (viewport_allocation.y +
- viewport_allocation.height +
+ child_allocation.y = (relative_allocation.y +
+ relative_allocation.height +
SCROLLBAR_SPACING (scrolled_window));
else
child_allocation.y = GTK_CONTAINER (scrolled_window)->border_width;
- child_allocation.width = viewport_allocation.width;
+ child_allocation.width = relative_allocation.width;
child_allocation.height = scrolled_window->hscrollbar->requisition.height;
child_allocation.x += allocation->x;
child_allocation.y += allocation->y;
if (scrolled_window->window_placement == GTK_CORNER_TOP_LEFT ||
scrolled_window->window_placement == GTK_CORNER_BOTTOM_LEFT)
- child_allocation.x = (viewport_allocation.x +
- viewport_allocation.width +
+ child_allocation.x = (relative_allocation.x +
+ relative_allocation.width +
SCROLLBAR_SPACING (scrolled_window));
else
child_allocation.x = GTK_CONTAINER (scrolled_window)->border_width;
- child_allocation.y = viewport_allocation.y;
+ child_allocation.y = relative_allocation.y;
child_allocation.width = scrolled_window->vscrollbar->requisition.width;
- child_allocation.height = viewport_allocation.height;
+ child_allocation.height = relative_allocation.height;
child_allocation.x += allocation->x;
child_allocation.y += allocation->y;
gtk_widget_hide (scrolled_window->vscrollbar);
}
+
static void
-gtk_scrolled_window_add (GtkContainer *container,
- GtkWidget *widget)
+gtk_scrolled_window_adjustment_changed (GtkAdjustment *adjustment,
+ gpointer data)
{
- GtkScrolledWindow *scrolled_window;
- GtkArgInfo *info_hadj;
- GtkArgInfo *info_vadj;
- gchar *error;
-
- g_return_if_fail (container != NULL);
- g_return_if_fail (GTK_IS_SCROLLED_WINDOW (container));
- g_return_if_fail (widget != NULL);
+ GtkScrolledWindow *scrolled_win;
- scrolled_window = GTK_SCROLLED_WINDOW (container);
+ g_return_if_fail (adjustment != NULL);
+ g_return_if_fail (data != NULL);
- if (scrolled_window->viewport)
- gtk_container_remove (container, scrolled_window->viewport);
+ scrolled_win = GTK_SCROLLED_WINDOW (data);
- error = gtk_object_arg_get_info (GTK_OBJECT_TYPE (widget),
- "hadjustment", &info_hadj);
- if (!error)
+ if (adjustment == gtk_range_get_adjustment (GTK_RANGE (scrolled_win->hscrollbar)))
{
- error = gtk_object_arg_get_info (GTK_OBJECT_TYPE (widget),
- "vadjustment", &info_vadj);
-
- if (!error)
+ if (scrolled_win->hscrollbar_policy == GTK_POLICY_AUTOMATIC)
{
- gtk_object_set (GTK_OBJECT (widget),
- "hadjustment",
- gtk_scrolled_window_get_hadjustment
- (scrolled_window),
- "vadjustment",
- gtk_scrolled_window_get_vadjustment
- (scrolled_window),
- NULL);
- scrolled_window->viewport = widget;
- gtk_widget_set_parent (widget, GTK_WIDGET (scrolled_window));
- gtk_widget_ref (widget);
- scrolled_window->autogenerated_viewport = FALSE;
+ gboolean visible;
+
+ visible = scrolled_win->hscrollbar_visible;
+ scrolled_win->hscrollbar_visible = (adjustment->upper - adjustment->lower >
+ adjustment->page_size);
+ if (scrolled_win->hscrollbar_visible != visible)
+ gtk_widget_queue_resize (GTK_WIDGET (scrolled_win));
}
}
-
- if (error)
- {
- g_free (error);
-
- scrolled_window->viewport = gtk_viewport_new
- (gtk_scrolled_window_get_hadjustment (scrolled_window),
- gtk_scrolled_window_get_vadjustment (scrolled_window));
- gtk_widget_set_parent (scrolled_window->viewport,
- GTK_WIDGET (scrolled_window));
- gtk_widget_ref (scrolled_window->viewport);
- gtk_widget_show (scrolled_window->viewport);
- scrolled_window->autogenerated_viewport = FALSE;
-
- gtk_container_add (GTK_CONTAINER (scrolled_window->viewport), widget);
-
- widget = scrolled_window->viewport;
- }
-
- if (GTK_WIDGET_VISIBLE (scrolled_window))
+ else if (adjustment == gtk_range_get_adjustment (GTK_RANGE (scrolled_win->vscrollbar)))
{
- if (GTK_WIDGET_REALIZED (scrolled_window) &&
- !GTK_WIDGET_REALIZED (widget))
- gtk_widget_realize (widget);
+ if (scrolled_win->vscrollbar_policy == GTK_POLICY_AUTOMATIC)
+ {
+ gboolean visible;
- if (GTK_WIDGET_MAPPED (scrolled_window) &&
- !GTK_WIDGET_MAPPED (widget))
- gtk_widget_map (widget);
+ visible = scrolled_win->vscrollbar_visible;
+ scrolled_win->vscrollbar_visible = (adjustment->upper - adjustment->lower >
+ adjustment->page_size);
+ if (scrolled_win->vscrollbar_visible != visible)
+ gtk_widget_queue_resize (GTK_WIDGET (scrolled_win));
+ }
}
-
- if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (scrolled_window))
- gtk_widget_queue_resize (widget);
}
static void
-gtk_scrolled_window_remove (GtkContainer *container,
- GtkWidget *widget)
+gtk_scrolled_window_add (GtkContainer *container,
+ GtkWidget *child)
{
GtkScrolledWindow *scrolled_window;
- g_return_if_fail (container != NULL);
- g_return_if_fail (GTK_IS_SCROLLED_WINDOW (container));
- g_return_if_fail (widget != NULL);
-
scrolled_window = GTK_SCROLLED_WINDOW (container);
- if (scrolled_window->viewport == widget ||
- scrolled_window->hscrollbar == widget ||
- scrolled_window->vscrollbar == widget)
- {
- /* this happens during destroy */
+ g_return_if_fail (scrolled_window->child == NULL);
+
+ gtk_widget_set_parent (child, GTK_WIDGET (container));
+ scrolled_window->child = child;
- if (scrolled_window->viewport == widget)
- scrolled_window->autogenerated_viewport = FALSE;
+ /* this is a temporary message */
+ if (!gtk_widget_scroll_adjustements (child,
+ gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)),
+ gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar))))
+ g_message ("gtk_scrolled_window_add(): cannot add non scrollable widget "
+ "use gtk_scrolled_window_add_with_viewport() instead");
+
+ if (GTK_WIDGET_VISIBLE (scrolled_window))
+ {
+ if (GTK_WIDGET_REALIZED (scrolled_window) &&
+ !GTK_WIDGET_REALIZED (child))
+ gtk_widget_realize (child);
- gtk_widget_unparent (widget);
+ if (GTK_WIDGET_MAPPED (scrolled_window) &&
+ !GTK_WIDGET_MAPPED (child))
+ gtk_widget_map (child);
}
- else if (scrolled_window->autogenerated_viewport)
- gtk_container_remove (GTK_CONTAINER (scrolled_window->viewport), widget);
+
+ if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (scrolled_window))
+ gtk_widget_queue_resize (child);
}
static void
-gtk_scrolled_window_forall (GtkContainer *container,
- gboolean include_internals,
- GtkCallback callback,
- gpointer callback_data)
+gtk_scrolled_window_remove (GtkContainer *container,
+ GtkWidget *child)
{
GtkScrolledWindow *scrolled_window;
-
+ gboolean widget_was_visible;
+
g_return_if_fail (container != NULL);
g_return_if_fail (GTK_IS_SCROLLED_WINDOW (container));
- g_return_if_fail (callback != NULL);
+ g_return_if_fail (child != NULL);
scrolled_window = GTK_SCROLLED_WINDOW (container);
-
- if (scrolled_window->viewport)
- (* callback) (scrolled_window->viewport, callback_data);
- if (include_internals)
- {
- (* callback) (scrolled_window->vscrollbar, callback_data);
- (* callback) (scrolled_window->hscrollbar, callback_data);
- }
-}
-
-static void
-gtk_scrolled_window_viewport_allocate (GtkWidget *widget,
- GtkAllocation *allocation)
-{
- GtkScrolledWindow *scrolled_window;
-
- g_return_if_fail (widget != NULL);
- g_return_if_fail (allocation != NULL);
-
- scrolled_window = GTK_SCROLLED_WINDOW (widget);
-
- allocation->x = GTK_CONTAINER (widget)->border_width;
- allocation->y = GTK_CONTAINER (widget)->border_width;
- allocation->width = MAX (1, widget->allocation.width - allocation->x * 2);
- allocation->height = MAX (1, widget->allocation.height - allocation->y * 2);
-
- if (scrolled_window->vscrollbar_visible)
- {
- if (scrolled_window->window_placement == GTK_CORNER_TOP_RIGHT ||
- scrolled_window->window_placement == GTK_CORNER_BOTTOM_RIGHT)
- allocation->x += (scrolled_window->vscrollbar->requisition.width +
- SCROLLBAR_SPACING (scrolled_window));
-
- allocation->width =
- MAX (1, allocation->width -
- (scrolled_window->vscrollbar->requisition.width +
- SCROLLBAR_SPACING (scrolled_window)));
- }
- if (scrolled_window->hscrollbar_visible)
- {
- if (scrolled_window->window_placement == GTK_CORNER_BOTTOM_LEFT ||
- scrolled_window->window_placement == GTK_CORNER_BOTTOM_RIGHT)
- allocation->y += (scrolled_window->hscrollbar->requisition.height +
- SCROLLBAR_SPACING (scrolled_window));
-
- allocation->height =
- MAX (1, allocation->height -
- (scrolled_window->hscrollbar->requisition.height +
- SCROLLBAR_SPACING (scrolled_window)));
- }
+ g_return_if_fail (scrolled_window->child == child);
+
+ widget_was_visible = GTK_WIDGET_VISIBLE (child);
+
+ gtk_widget_scroll_adjustements (child, NULL, NULL);
+ gtk_widget_unparent (child);
+ scrolled_window->child = NULL;
+
+ if (widget_was_visible)
+ gtk_widget_queue_resize (GTK_WIDGET (container));
}
-static void
-gtk_scrolled_window_adjustment_changed (GtkAdjustment *adjustment,
- gpointer data)
+void
+gtk_scrolled_window_add_with_viewport (GtkScrolledWindow *scrolled_window,
+ GtkWidget *child)
{
- GtkScrolledWindow *scrolled_win;
- gboolean visible;
-
- g_return_if_fail (adjustment != NULL);
- g_return_if_fail (data != NULL);
+ GtkWidget *viewport;
- scrolled_win = GTK_SCROLLED_WINDOW (data);
-
- if (adjustment == gtk_range_get_adjustment (GTK_RANGE (scrolled_win->hscrollbar)))
- {
- if (scrolled_win->hscrollbar_policy == GTK_POLICY_AUTOMATIC)
- {
- visible = scrolled_win->hscrollbar_visible;
- scrolled_win->hscrollbar_visible =
- ((adjustment->upper - adjustment->lower) > adjustment->page_size);
- if (scrolled_win->hscrollbar_visible != visible)
- gtk_widget_queue_resize (GTK_WIDGET (scrolled_win));
- }
- }
- else if (adjustment == gtk_range_get_adjustment (GTK_RANGE (scrolled_win->vscrollbar)))
- {
- if (scrolled_win->vscrollbar_policy == GTK_POLICY_AUTOMATIC)
- {
- visible = scrolled_win->vscrollbar_visible;
- scrolled_win->vscrollbar_visible =
- ((adjustment->upper - adjustment->lower) > adjustment->page_size);
- if (scrolled_win->vscrollbar_visible != visible)
- gtk_widget_queue_resize (GTK_WIDGET (scrolled_win));
- }
- }
- else
- {
- g_warning ("could not determine which adjustment scrollbar received change signal for");
- return;
- }
+ g_return_if_fail (scrolled_window != NULL);
+ g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
+ g_return_if_fail (child != NULL);
+ g_return_if_fail (GTK_IS_WIDGET (child));
+ g_return_if_fail (scrolled_window->child == NULL);
+ g_return_if_fail (child->parent == NULL);
+
+ viewport =
+ gtk_viewport_new (gtk_scrolled_window_get_hadjustment (scrolled_window),
+ gtk_scrolled_window_get_vadjustment (scrolled_window));
+ gtk_widget_show (viewport);
+ gtk_container_add (GTK_CONTAINER (viewport), child);
+ gtk_container_add (GTK_CONTAINER (scrolled_window), viewport);
}
{
GtkContainer container;
- GtkWidget *viewport;
+ GtkWidget *child;
GtkWidget *hscrollbar;
GtkWidget *vscrollbar;
guint hscrollbar_visible : 1;
guint vscrollbar_visible : 1;
guint window_placement : 2;
- guint autogenerated_viewport : 1;
};
struct _GtkScrolledWindowClass
{
GtkContainerClass parent_class;
-
+
gint scrollbar_spacing;
};
-GtkType gtk_scrolled_window_get_type (void);
-GtkWidget* gtk_scrolled_window_new (GtkAdjustment *hadjustment,
- GtkAdjustment *vadjustment);
-void gtk_scrolled_window_construct (GtkScrolledWindow *scrolled_window,
- GtkAdjustment *hadjustment,
- GtkAdjustment *vadjustment);
-GtkAdjustment* gtk_scrolled_window_get_hadjustment (GtkScrolledWindow *scrolled_window);
-GtkAdjustment* gtk_scrolled_window_get_vadjustment (GtkScrolledWindow *scrolled_window);
-void gtk_scrolled_window_set_policy (GtkScrolledWindow *scrolled_window,
- GtkPolicyType hscrollbar_policy,
- GtkPolicyType vscrollbar_policy);
-void gtk_scrolled_window_set_placement (GtkScrolledWindow *scrolled_window,
- GtkCornerType window_placement);
+GtkType gtk_scrolled_window_get_type (void);
+GtkWidget* gtk_scrolled_window_new (GtkAdjustment *hadjustment,
+ GtkAdjustment *vadjustment);
+void gtk_scrolled_window_set_hadjustment (GtkScrolledWindow *scrolled_window,
+ GtkAdjustment *hadjustment);
+void gtk_scrolled_window_set_vadjustment (GtkScrolledWindow *scrolled_window,
+ GtkAdjustment *hadjustment);
+GtkAdjustment* gtk_scrolled_window_get_hadjustment (GtkScrolledWindow *scrolled_window);
+GtkAdjustment* gtk_scrolled_window_get_vadjustment (GtkScrolledWindow *scrolled_window);
+void gtk_scrolled_window_set_policy (GtkScrolledWindow *scrolled_window,
+ GtkPolicyType hscrollbar_policy,
+ GtkPolicyType vscrollbar_policy);
+void gtk_scrolled_window_set_placement (GtkScrolledWindow *scrolled_window,
+ GtkCornerType window_placement);
+void gtk_scrolled_window_add_with_viewport (GtkScrolledWindow *scrolled_window,
+ GtkWidget *child);
+
+/* deprecated */
+void gtk_scrolled_window_construct (GtkScrolledWindow *scrolled_window,
+ GtkAdjustment *hadjustment,
+ GtkAdjustment *vadjustment);
#ifdef __cplusplus
}
static void
gtk_separator_init (GtkSeparator *separator)
{
- GTK_WIDGET_SET_FLAGS (separator, GTK_NO_WINDOW | GTK_BASIC);
+ GTK_WIDGET_SET_FLAGS (separator, GTK_NO_WINDOW);
}
***********************************************************/
+void
+gtk_spin_button_construct (GtkSpinButton *spin_button,
+ GtkAdjustment *adjustment,
+ gfloat climb_rate,
+ guint digits)
+{
+ g_message ("gtk_spin_button_construct() is deprecated");
+
+ gtk_spin_button_configure (spin_button, adjustment, climb_rate, digits);
+}
+
void
gtk_spin_button_configure (GtkSpinButton *spin_button,
GtkAdjustment *adjustment,
void gtk_spin_button_set_snap_to_ticks (GtkSpinButton *spin_button,
gboolean snap_to_ticks);
-/* deprecated, defined for backwards compatibility */
-#define gtk_spin_button_construct gtk_spin_button_configure
+void gtk_spin_button_configure (GtkSpinButton *spin_button,
+ GtkAdjustment *adjustment,
+ gfloat climb_rate,
+ guint digits);
+/* deprecated */
+void gtk_spin_button_construct (GtkSpinButton *spin_button,
+ GtkAdjustment *adjustment,
+ gfloat climb_rate,
+ guint digits);
#ifdef __cplusplus
static void
gtk_table_init (GtkTable *table)
{
- GTK_WIDGET_SET_FLAGS (table, GTK_NO_WINDOW | GTK_BASIC);
+ GTK_WIDGET_SET_FLAGS (table, GTK_NO_WINDOW);
table->children = NULL;
table->rows = NULL;
#define LAST_INDEX(t, m) ((m).index == TEXT_LENGTH(t))
#define CACHE_DATA(c) (*(LineParams*)(c)->data)
+enum {
+ ARG_0,
+ ARG_HADJUSTMENT,
+ ARG_VADJUSTMENT,
+ ARG_LINE_WRAP,
+ ARG_WORD_WRAP
+};
+
typedef struct _TextProperty TextProperty;
typedef struct _TabStopMark TabStopMark;
typedef struct _PrevTabCont PrevTabCont;
static void gtk_text_class_init (GtkTextClass *klass);
+static void gtk_text_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
+static void gtk_text_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
static void gtk_text_init (GtkText *text);
static void gtk_text_destroy (GtkObject *object);
static void gtk_text_finalize (GtkObject *object);
object_class = (GtkObjectClass*) class;
widget_class = (GtkWidgetClass*) class;
editable_class = (GtkEditableClass*) class;
-
parent_class = gtk_type_class (GTK_TYPE_EDITABLE);
-
+
+ gtk_object_add_arg_type ("GtkText::hadjustment",
+ GTK_TYPE_ADJUSTMENT,
+ GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
+ ARG_HADJUSTMENT);
+ gtk_object_add_arg_type ("GtkText::vadjustment",
+ GTK_TYPE_ADJUSTMENT,
+ GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
+ ARG_VADJUSTMENT);
+ gtk_object_add_arg_type ("GtkText::line_wrap",
+ GTK_TYPE_BOOL,
+ GTK_ARG_READWRITE,
+ ARG_LINE_WRAP);
+ gtk_object_add_arg_type ("GtkText::word_wrap",
+ GTK_TYPE_BOOL,
+ GTK_ARG_READWRITE,
+ ARG_WORD_WRAP);
+
+ object_class->set_arg = gtk_text_set_arg;
+ object_class->get_arg = gtk_text_get_arg;
object_class->destroy = gtk_text_destroy;
object_class->finalize = gtk_text_finalize;
widget_class->focus_in_event = gtk_text_focus_in;
widget_class->focus_out_event = gtk_text_focus_out;
+ widget_class->scroll_adjustments_signal =
+ gtk_signal_new ("scroll_adjustments",
+ GTK_RUN_LAST,
+ object_class->type,
+ GTK_SIGNAL_OFFSET (GtkTextClass, scroll_adjustments),
+ gtk_marshal_NONE__POINTER_POINTER,
+ GTK_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
+
editable_class->set_editable = gtk_text_real_set_editable;
editable_class->insert_text = gtk_text_insert_text;
editable_class->delete_text = gtk_text_delete_text;
editable_class->get_chars = gtk_text_get_chars;
editable_class->set_selection = gtk_text_set_selection;
editable_class->set_position = gtk_text_set_position;
+
+ class->scroll_adjustments = gtk_text_set_adjustments;
+}
+
+static void
+gtk_text_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkText *text;
+
+ text = GTK_TEXT (object);
+
+ switch (arg_id)
+ {
+ case ARG_HADJUSTMENT:
+ gtk_text_set_adjustments (text,
+ GTK_VALUE_POINTER (*arg),
+ text->vadj);
+ break;
+ case ARG_VADJUSTMENT:
+ gtk_text_set_adjustments (text,
+ text->hadj,
+ GTK_VALUE_POINTER (*arg));
+ break;
+ case ARG_LINE_WRAP:
+ gtk_text_set_line_wrap (text, GTK_VALUE_BOOL (*arg));
+ break;
+ case ARG_WORD_WRAP:
+ gtk_text_set_word_wrap (text, GTK_VALUE_BOOL (*arg));
+ break;
+ default:
+ break;
+ }
+}
+
+static void
+gtk_text_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkText *text;
+
+ text = GTK_TEXT (object);
+
+ switch (arg_id)
+ {
+ case ARG_HADJUSTMENT:
+ GTK_VALUE_POINTER (*arg) = text->hadj;
+ break;
+ case ARG_VADJUSTMENT:
+ GTK_VALUE_POINTER (*arg) = text->vadj;
+ break;
+ case ARG_LINE_WRAP:
+ GTK_VALUE_BOOL (*arg) = text->line_wrap;
+ break;
+ case ARG_WORD_WRAP:
+ GTK_VALUE_BOOL (*arg) = text->word_wrap;
+ break;
+ default:
+ arg->type = GTK_TYPE_INVALID;
+ break;
+ }
}
static void
gtk_text_init (GtkText *text)
{
GTK_WIDGET_SET_FLAGS (text, GTK_CAN_FOCUS);
+
+ text->text_area = NULL;
+ text->hadj = NULL;
+ text->vadj = NULL;
+ text->gc = NULL;
+ text->line_wrap_bitmap = NULL;
+ text->line_arrow_bitmap = NULL;
text->text = g_new (guchar, INITIAL_BUFFER_SIZE);
text->text_len = INITIAL_BUFFER_SIZE;
text->button = 0;
text->current_font = NULL;
-
+
init_properties (text);
-
- GTK_EDITABLE(text)->editable = FALSE;
+
+ GTK_EDITABLE (text)->editable = FALSE;
+
+ gtk_editable_set_position (GTK_EDITABLE (text), 0);
}
GtkWidget*
gtk_text_new (GtkAdjustment *hadj,
GtkAdjustment *vadj)
{
- GtkText *text;
-
- text = gtk_type_new (GTK_TYPE_TEXT);
-
- gtk_text_set_adjustments (text, hadj, vadj);
- gtk_editable_set_position (GTK_EDITABLE (text), 0);
-
- return GTK_WIDGET (text);
+ GtkWidget *text;
+
+ if (hadj)
+ g_return_val_if_fail (GTK_IS_ADJUSTMENT (hadj), NULL);
+ if (vadj)
+ g_return_val_if_fail (GTK_IS_ADJUSTMENT (vadj), NULL);
+
+ text = gtk_widget_new (GTK_TYPE_TEXT,
+ "hadjustment", hadj,
+ "vadjustment", vadj,
+ NULL);
+
+ return text;
}
void
gtk_signal_connect (GTK_OBJECT (text->hadj), "disconnect",
(GtkSignalFunc) gtk_text_disconnect,
text);
+ gtk_text_adjustment (hadj, text);
}
if (text->vadj != vadj)
gtk_signal_connect (GTK_OBJECT (text->vadj), "disconnect",
(GtkSignalFunc) gtk_text_disconnect,
text);
+ gtk_text_adjustment (vadj, text);
}
}
g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_TEXT (object));
- text = (GtkText *)object;
- if (text->hadj)
- {
- gtk_object_unref (GTK_OBJECT (text->hadj));
- text->hadj = NULL;
- }
- if (text->vadj)
- {
- gtk_object_unref (GTK_OBJECT (text->vadj));
- text->vadj = NULL;
- }
+ text = (GtkText*) object;
+
+ gtk_signal_disconnect_by_data (GTK_OBJECT (text->hadj), text);
+ gtk_signal_disconnect_by_data (GTK_OBJECT (text->hadj), text);
+
if (text->timer)
{
gtk_timeout_remove (text->timer);
text = (GtkText *)object;
+ gtk_object_unref (GTK_OBJECT (text->hadj));
+ gtk_object_unref (GTK_OBJECT (text->vadj));
+
/* Clean up the internal structures */
g_free (text->text);
free_cache (text);
g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
g_return_if_fail (text != NULL);
g_return_if_fail (GTK_IS_TEXT (text));
-
+
if (adjustment == text->hadj)
- text->hadj = NULL;
+ gtk_text_set_adjustments (text, NULL, text->vadj);
if (adjustment == text->vadj)
- text->vadj = NULL;
+ gtk_text_set_adjustments (text, text->hadj, NULL);
}
struct _GtkTextClass
{
GtkEditableClass parent_class;
+
+ void (*scroll_adjustments) (GtkText *text,
+ GtkAdjustment *hadjustment,
+ GtkAdjustment *vadjustment);
};
/* we need to call the base classes' object_init_func for derived
* objects with the object's ->klass field still pointing to the
* corresponding base class, otherwise overridden class functions
- * could get called with partly-initialized objects.
+ * could get called with partly-initialized objects. the real object
+ * class is passed as second argment to the initializers.
*/
if (node->n_supers)
{
guint i;
GtkType *supers;
+ GtkTypeNode *pnode;
supers = node->supers;
for (i = node->n_supers; i > 0; i--)
{
- GtkTypeNode *pnode;
-
LOOKUP_TYPE_NODE (pnode, supers[i]);
if (pnode->type_info.object_init_func)
{
tobject->klass = pnode->klass;
- pnode->type_info.object_init_func (tobject);
+ pnode->type_info.object_init_func (tobject, klass);
}
}
LOOKUP_TYPE_NODE (node, type);
}
tobject->klass = klass;
if (node->type_info.object_init_func)
- node->type_info.object_init_func (tobject);
+ {
+ node->type_info.object_init_func (tobject, klass);
+ tobject->klass = klass;
+ }
return tobject;
}
}
GtkType
-gtk_type_get_varargs_type (GtkType foreign_type)
+gtk_type_get_varargs_type (GtkType foreign_type)
{
GtkType type;
guint i;
#define GTK_TYPE_STRUCTURED_FIRST GTK_TYPE_SIGNAL
#define GTK_TYPE_STRUCTURED_LAST GTK_TYPE_FOREIGN
#define GTK_TYPE_FUNDAMENTAL_LAST GTK_TYPE_OBJECT
+#define GTK_TYPE_FUNDAMENTAL_MAX (32)
/* retrive a structure offset */
#define GTK_SIGNAL_FUNC(f) ((GtkSignalFunc) f)
typedef void (*GtkClassInitFunc) (gpointer klass);
-typedef void (*GtkObjectInitFunc) (gpointer object);
+typedef void (*GtkObjectInitFunc) (gpointer object,
+ gpointer klass);
typedef void (*GtkSignalFunc) ();
typedef gint (*GtkFunction) (gpointer data);
typedef void (*GtkDestroyNotify) (gpointer data);
#endif /* __cplusplus */
-#define GTK_TYPE_VBOX (gtk_vbox_get_type ())
-#define GTK_VBOX(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_VBOX, GtkVBox))
-#define GTK_VBOX_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_VBOX, GtkVBoxClass))
-#define GTK_IS_VBOX(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_VBOX))
-#define GTK_IS_VBOX_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_VBOX))
+#define GTK_TYPE_VBOX (gtk_vbox_get_type ())
+#define GTK_VBOX(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_VBOX, GtkVBox))
+#define GTK_VBOX_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_VBOX, GtkVBoxClass))
+#define GTK_IS_VBOX(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_VBOX))
+#define GTK_IS_VBOX_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_VBOX))
typedef struct _GtkVBox GtkVBox;
};
-
static void gtk_viewport_class_init (GtkViewportClass *klass);
static void gtk_viewport_init (GtkViewport *viewport);
+static void gtk_viewport_destroy (GtkObject *object);
static void gtk_viewport_finalize (GtkObject *object);
static void gtk_viewport_set_arg (GtkObject *object,
GtkArg *arg,
static void gtk_viewport_get_arg (GtkObject *object,
GtkArg *arg,
guint arg_id);
+static void gtk_viewport_scroll_adjustments (GtkViewport *viewport,
+ GtkAdjustment *hadjustment,
+ GtkAdjustment *vadjustment);
static void gtk_viewport_map (GtkWidget *widget);
static void gtk_viewport_unmap (GtkWidget *widget);
static void gtk_viewport_realize (GtkWidget *widget);
object_class->set_arg = gtk_viewport_set_arg;
object_class->get_arg = gtk_viewport_get_arg;
+ object_class->destroy = gtk_viewport_destroy;
object_class->finalize = gtk_viewport_finalize;
widget_class->map = gtk_viewport_map;
widget_class->size_request = gtk_viewport_size_request;
widget_class->size_allocate = gtk_viewport_size_allocate;
widget_class->style_set = gtk_viewport_style_set;
-
+
+ widget_class->scroll_adjustments_signal =
+ gtk_signal_new ("scroll_adjustments",
+ GTK_RUN_LAST,
+ object_class->type,
+ GTK_SIGNAL_OFFSET (GtkViewportClass, scroll_adjustments),
+ gtk_marshal_NONE__POINTER_POINTER,
+ GTK_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
+
container_class->add = gtk_viewport_add;
+
+ class->scroll_adjustments = gtk_viewport_scroll_adjustments;
}
static void
switch (arg_id)
{
- GtkAdjustment *adjustment;
-
case ARG_HADJUSTMENT:
- adjustment = GTK_VALUE_POINTER (*arg);
- gtk_viewport_set_hadjustment (viewport, adjustment);
+ gtk_viewport_set_hadjustment (viewport, GTK_VALUE_POINTER (*arg));
break;
case ARG_VADJUSTMENT:
- adjustment = GTK_VALUE_POINTER (*arg);
- gtk_viewport_set_vadjustment (viewport, adjustment);
+ gtk_viewport_set_vadjustment (viewport, GTK_VALUE_POINTER (*arg));
break;
case ARG_SHADOW_TYPE:
gtk_viewport_set_shadow_type (viewport, GTK_VALUE_ENUM (*arg));
gtk_viewport_init (GtkViewport *viewport)
{
GTK_WIDGET_UNSET_FLAGS (viewport, GTK_NO_WINDOW);
- GTK_WIDGET_SET_FLAGS (viewport, GTK_BASIC);
gtk_container_set_resize_mode (GTK_CONTAINER (viewport), GTK_RESIZE_QUEUE);
gtk_viewport_new (GtkAdjustment *hadjustment,
GtkAdjustment *vadjustment)
{
- GtkViewport *viewport;
+ GtkWidget *viewport;
- viewport = gtk_type_new (gtk_viewport_get_type ());
+ viewport = gtk_widget_new (GTK_TYPE_VIEWPORT,
+ "hadjustment", hadjustment,
+ "vadjustment", vadjustment,
+ NULL);
- gtk_viewport_set_hadjustment (viewport, hadjustment);
- gtk_viewport_set_vadjustment (viewport, vadjustment);
+ return viewport;
+}
- return GTK_WIDGET (viewport);
+static void
+gtk_viewport_destroy (GtkObject *object)
+{
+ GtkViewport *viewport = GTK_VIEWPORT (object);
+
+ if (viewport->hadjustment)
+ gtk_signal_disconnect_by_data (GTK_OBJECT (viewport->hadjustment),
+ viewport);
+ if (viewport->vadjustment)
+ gtk_signal_disconnect_by_data (GTK_OBJECT (viewport->vadjustment),
+ viewport);
+
+ GTK_OBJECT_CLASS(parent_class)->destroy (object);
}
static void
}
}
+static void
+gtk_viewport_scroll_adjustments (GtkViewport *viewport,
+ GtkAdjustment *hadjustment,
+ GtkAdjustment *vadjustment)
+{
+ if (viewport->hadjustment != hadjustment)
+ gtk_viewport_set_hadjustment (viewport, hadjustment);
+ if (viewport->vadjustment != vadjustment)
+ gtk_viewport_set_vadjustment (viewport, vadjustment);
+}
+
void
gtk_viewport_set_shadow_type (GtkViewport *viewport,
GtkShadowType type)
struct _GtkViewportClass
{
GtkBinClass parent_class;
+
+ void (*scroll_adjustments) (GtkViewport *viewport,
+ GtkAdjustment *hadjustment,
+ GtkAdjustment *vadjustment);
};
#define SCALE_CLASS(w) GTK_SCALE_CLASS (GTK_OBJECT (w)->klass)
#define RANGE_CLASS(w) GTK_RANGE_CLASS (GTK_OBJECT (w)->klass)
+enum {
+ ARG_0,
+ ARG_ADJUSTMENT,
+};
static void gtk_vscale_class_init (GtkVScaleClass *klass);
static void gtk_vscale_init (GtkVScale *vscale);
+static void gtk_vscale_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
+static void gtk_vscale_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
static void gtk_vscale_realize (GtkWidget *widget);
static void gtk_vscale_size_request (GtkWidget *widget,
- GtkRequisition *requisition);
+ GtkRequisition *requisition);
static void gtk_vscale_size_allocate (GtkWidget *widget,
- GtkAllocation *allocation);
+ GtkAllocation *allocation);
static void gtk_vscale_pos_trough (GtkVScale *vscale,
- gint *x,
- gint *y,
- gint *w,
- gint *h);
+ gint *x,
+ gint *y,
+ gint *w,
+ gint *h);
static void gtk_vscale_pos_background (GtkVScale *vscale,
- gint *x,
- gint *y,
- gint *w,
- gint *h);
+ gint *x,
+ gint *y,
+ gint *w,
+ gint *h);
static void gtk_vscale_draw_slider (GtkRange *range);
static void gtk_vscale_draw_value (GtkScale *scale);
static void gtk_vscale_draw (GtkWidget *widget,
- GdkRectangle *area);
+ GdkRectangle *area);
static gint gtk_vscale_trough_keys (GtkRange *range,
- GdkEventKey *key,
- GtkScrollType *scroll,
- GtkTroughType *pos);
+ GdkEventKey *key,
+ GtkScrollType *scroll,
+ GtkTroughType *pos);
static void gtk_vscale_clear_background (GtkRange *range);
-guint
+GtkType
gtk_vscale_get_type (void)
{
- static guint vscale_type = 0;
-
+ static GtkType vscale_type = 0;
+
if (!vscale_type)
{
GtkTypeInfo vscale_info =
{
- "GtkVScale",
- sizeof (GtkVScale),
- sizeof (GtkVScaleClass),
- (GtkClassInitFunc) gtk_vscale_class_init,
- (GtkObjectInitFunc) gtk_vscale_init,
- /* reserved_1 */ NULL,
+ "GtkVScale",
+ sizeof (GtkVScale),
+ sizeof (GtkVScaleClass),
+ (GtkClassInitFunc) gtk_vscale_class_init,
+ (GtkObjectInitFunc) gtk_vscale_init,
+ /* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
};
-
- vscale_type = gtk_type_unique (gtk_scale_get_type (), &vscale_info);
+
+ vscale_type = gtk_type_unique (GTK_TYPE_SCALE, &vscale_info);
}
-
+
return vscale_type;
}
static void
gtk_vscale_class_init (GtkVScaleClass *class)
{
+ GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
GtkRangeClass *range_class;
GtkScaleClass *scale_class;
-
+
+ object_class = (GtkObjectClass*) class;
widget_class = (GtkWidgetClass*) class;
range_class = (GtkRangeClass*) class;
scale_class = (GtkScaleClass*) class;
-
+
+ gtk_object_add_arg_type ("GtkVScale::adjustment",
+ GTK_TYPE_ADJUSTMENT,
+ GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
+ ARG_ADJUSTMENT);
+
+ object_class->set_arg = gtk_vscale_set_arg;
+ object_class->get_arg = gtk_vscale_get_arg;
+
widget_class->realize = gtk_vscale_realize;
widget_class->size_request = gtk_vscale_size_request;
widget_class->size_allocate = gtk_vscale_size_allocate;
widget_class->draw = gtk_vscale_draw;
-
+
range_class->slider_update = gtk_range_default_vslider_update;
range_class->trough_click = gtk_range_default_vtrough_click;
range_class->motion = gtk_range_default_vmotion;
range_class->draw_slider = gtk_vscale_draw_slider;
range_class->trough_keys = gtk_vscale_trough_keys;
range_class->clear_background = gtk_vscale_clear_background;
-
+
scale_class->draw_value = gtk_vscale_draw_value;
}
+static void
+gtk_vscale_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkVScale *vscale;
+
+ vscale = GTK_VSCALE (object);
+
+ switch (arg_id)
+ {
+ case ARG_ADJUSTMENT:
+ gtk_range_set_adjustment (GTK_RANGE (vscale), GTK_VALUE_POINTER (*arg));
+ break;
+ default:
+ break;
+ }
+}
+
+static void
+gtk_vscale_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkVScale *vscale;
+
+ vscale = GTK_VSCALE (object);
+
+ switch (arg_id)
+ {
+ case ARG_ADJUSTMENT:
+ GTK_VALUE_POINTER (*arg) = GTK_RANGE (vscale);
+ break;
+ default:
+ arg->type = GTK_TYPE_INVALID;
+ break;
+ }
+}
+
static void
gtk_vscale_init (GtkVScale *vscale)
{
GtkWidget*
gtk_vscale_new (GtkAdjustment *adjustment)
{
- GtkVScale *vscale;
-
- vscale = gtk_type_new (gtk_vscale_get_type ());
-
- if (!adjustment)
- adjustment = (GtkAdjustment*) gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
-
- gtk_range_set_adjustment (GTK_RANGE (vscale), adjustment);
-
- return GTK_WIDGET (vscale);
+ GtkWidget *vscale;
+
+ vscale = gtk_widget_new (GTK_TYPE_VSCALE,
+ "adjustment", adjustment,
+ NULL);
+
+ return vscale;
}
GdkWindowAttr attributes;
gint attributes_mask;
gint x, y, w, h;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_VSCALE (widget));
-
+
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
range = GTK_RANGE (widget);
-
+
widget->window = gtk_widget_get_parent_window (widget);
gdk_window_ref (widget->window);
-
+
gtk_vscale_pos_trough (GTK_VSCALE (widget), &x, &y, &w, &h);
-
+
attributes.x = x;
attributes.y = y;
attributes.width = w;
attributes.height = h;
attributes.wclass = GDK_INPUT_OUTPUT;
+ attributes.window_type = GDK_WINDOW_CHILD;
+
attributes.event_mask = gtk_widget_get_events (widget) |
- (GDK_EXPOSURE_MASK |
- GDK_BUTTON_PRESS_MASK |
- GDK_BUTTON_RELEASE_MASK |
- GDK_ENTER_NOTIFY_MASK |
- GDK_LEAVE_NOTIFY_MASK);
+ (GDK_EXPOSURE_MASK |
+ GDK_BUTTON_PRESS_MASK |
+ GDK_BUTTON_RELEASE_MASK |
+ GDK_ENTER_NOTIFY_MASK |
+ GDK_LEAVE_NOTIFY_MASK);
attributes.visual = gtk_widget_get_visual (widget);
attributes.colormap = gtk_widget_get_colormap (widget);
-
+
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
-
+
range->trough = gdk_window_new (widget->window, &attributes, attributes_mask);
-
+
attributes.width = RANGE_CLASS (range)->slider_width;
attributes.height = SCALE_CLASS (range)->slider_length;
attributes.event_mask |= (GDK_BUTTON_MOTION_MASK |
- GDK_POINTER_MOTION_HINT_MASK);
-
+ GDK_POINTER_MOTION_HINT_MASK);
+
range->slider = gdk_window_new (range->trough, &attributes, attributes_mask);
-
+
widget->style = gtk_style_attach (widget->style, widget->window);
-
+
gdk_window_set_user_data (range->trough, widget);
gdk_window_set_user_data (range->slider, widget);
-
+
gtk_style_set_background (widget->style, range->trough, GTK_STATE_ACTIVE);
gtk_style_set_background (widget->style, range->slider, GTK_STATE_NORMAL);
-
+
gtk_range_slider_update (GTK_RANGE (widget));
-
+
gdk_window_show (range->slider);
- gdk_window_show (range->trough);
}
static void
gtk_vscale_draw (GtkWidget *widget,
- GdkRectangle *area)
+ GdkRectangle *area)
{
GtkRange *range;
GdkRectangle tmp_area;
GdkRectangle child_area;
gint x, y, width, height;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_RANGE (widget));
g_return_if_fail (area != NULL);
-
+
if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_MAPPED (widget))
{
range = GTK_RANGE (widget);
-
+
gtk_vscale_pos_background (GTK_VSCALE (widget), &x, &y, &width, &height);
-
+
tmp_area.x = x;
tmp_area.y = y;
tmp_area.width = width;
tmp_area.height = height;
-
+
if (gdk_rectangle_intersect (area, &tmp_area, &child_area))
- gtk_range_draw_background (range);
-
+ gtk_range_draw_background (range);
+
gtk_vscale_pos_trough (GTK_VSCALE (widget), &x, &y, &width, &height);
-
+
tmp_area.x = x;
tmp_area.y = y;
tmp_area.width = width;
tmp_area.height = height;
-
+
if (gdk_rectangle_intersect (area, &tmp_area, &child_area))
- {
- gtk_range_draw_trough (range);
- gtk_range_draw_slider (range);
- gtk_range_draw_step_forw (range);
- gtk_range_draw_step_back (range);
- }
+ {
+ gtk_range_draw_trough (range);
+ gtk_range_draw_slider (range);
+ gtk_range_draw_step_forw (range);
+ gtk_range_draw_step_back (range);
+ }
}
}
GtkWidget *widget;
GtkScale *scale;
gint x, y, width, height;
-
+
g_return_if_fail (range != NULL);
g_return_if_fail (GTK_IS_SCALE (range));
-
+
widget = GTK_WIDGET (range);
scale = GTK_SCALE (range);
-
+
gtk_vscale_pos_background (GTK_VSCALE (widget), &x, &y, &width, &height);
-
+
gtk_widget_queue_clear_area (GTK_WIDGET (range),
- x, y, width, height);
+ x, y, width, height);
}
static void
gtk_vscale_size_request (GtkWidget *widget,
- GtkRequisition *requisition)
+ GtkRequisition *requisition)
{
GtkScale *scale;
gint value_width;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_VSCALE (widget));
g_return_if_fail (requisition != NULL);
-
+
scale = GTK_SCALE (widget);
-
+
requisition->width = (RANGE_CLASS (scale)->slider_width +
- widget->style->klass->ythickness * 2);
+ widget->style->klass->ythickness * 2);
requisition->height = (SCALE_CLASS (scale)->slider_length +
- widget->style->klass->xthickness) * 2;
-
+ widget->style->klass->xthickness) * 2;
+
if (scale->draw_value)
{
value_width = gtk_scale_value_width (scale);
-
+
if ((scale->value_pos == GTK_POS_LEFT) ||
- (scale->value_pos == GTK_POS_RIGHT))
- {
- requisition->width += value_width + SCALE_CLASS (scale)->value_spacing;
- if (requisition->height < (widget->style->font->ascent + widget->style->font->descent))
- requisition->height = widget->style->font->ascent + widget->style->font->descent;
- }
+ (scale->value_pos == GTK_POS_RIGHT))
+ {
+ requisition->width += value_width + SCALE_CLASS (scale)->value_spacing;
+ if (requisition->height < (widget->style->font->ascent + widget->style->font->descent))
+ requisition->height = widget->style->font->ascent + widget->style->font->descent;
+ }
else if ((scale->value_pos == GTK_POS_TOP) ||
- (scale->value_pos == GTK_POS_BOTTOM))
- {
- if (requisition->width < value_width)
- requisition->width = value_width;
- requisition->height += widget->style->font->ascent + widget->style->font->descent;
- }
+ (scale->value_pos == GTK_POS_BOTTOM))
+ {
+ if (requisition->width < value_width)
+ requisition->width = value_width;
+ requisition->height += widget->style->font->ascent + widget->style->font->descent;
+ }
}
}
static void
gtk_vscale_size_allocate (GtkWidget *widget,
- GtkAllocation *allocation)
+ GtkAllocation *allocation)
{
GtkRange *range;
GtkScale *scale;
gint width, height;
gint x, y;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_VSCALE (widget));
g_return_if_fail (allocation != NULL);
-
+
widget->allocation = *allocation;
if (GTK_WIDGET_REALIZED (widget))
{
range = GTK_RANGE (widget);
scale = GTK_SCALE (widget);
-
+
gtk_vscale_pos_trough (GTK_VSCALE (widget), &x, &y, &width, &height);
-
+
gdk_window_move_resize (range->trough, x, y, width, height);
gtk_range_slider_update (GTK_RANGE (widget));
}
static void
gtk_vscale_pos_trough (GtkVScale *vscale,
- gint *x,
- gint *y,
- gint *w,
- gint *h)
+ gint *x,
+ gint *y,
+ gint *w,
+ gint *h)
{
GtkWidget *widget;
GtkScale *scale;
-
+
g_return_if_fail (vscale != NULL);
g_return_if_fail (GTK_IS_VSCALE (vscale));
g_return_if_fail ((x != NULL) && (y != NULL) && (w != NULL) && (h != NULL));
-
+
widget = GTK_WIDGET (vscale);
scale = GTK_SCALE (vscale);
-
+
*w = (RANGE_CLASS (scale)->slider_width +
- widget->style->klass->xthickness * 2);
+ widget->style->klass->xthickness * 2);
*h = widget->allocation.height;
-
+
if (scale->draw_value)
{
*x = 0;
*y = 0;
-
+
switch (scale->value_pos)
- {
- case GTK_POS_LEFT:
- *x = (gtk_scale_value_width (scale) +
- (widget->allocation.width - widget->requisition.width) / 2);
- break;
- case GTK_POS_RIGHT:
- *x = (widget->allocation.width - widget->requisition.width) / 2;
- break;
- case GTK_POS_TOP:
- *x = (widget->allocation.width - *w) / 2;
- *y = widget->style->font->ascent + widget->style->font->descent;
- *h -= *y;
- break;
- case GTK_POS_BOTTOM:
- *x = (widget->allocation.width - *w) / 2;
- *h -= widget->style->font->ascent + widget->style->font->descent;
- break;
- }
+ {
+ case GTK_POS_LEFT:
+ *x = (gtk_scale_value_width (scale) +
+ (widget->allocation.width - widget->requisition.width) / 2);
+ break;
+ case GTK_POS_RIGHT:
+ *x = (widget->allocation.width - widget->requisition.width) / 2;
+ break;
+ case GTK_POS_TOP:
+ *x = (widget->allocation.width - *w) / 2;
+ *y = widget->style->font->ascent + widget->style->font->descent;
+ *h -= *y;
+ break;
+ case GTK_POS_BOTTOM:
+ *x = (widget->allocation.width - *w) / 2;
+ *h -= widget->style->font->ascent + widget->style->font->descent;
+ break;
+ }
}
else
{
}
*y += 1;
*h -= 2;
-
+
*x += widget->allocation.x;
*y += widget->allocation.y;
}
static void
gtk_vscale_pos_background (GtkVScale *vscale,
- gint *x,
- gint *y,
- gint *w,
- gint *h)
+ gint *x,
+ gint *y,
+ gint *w,
+ gint *h)
{
GtkWidget *widget;
GtkScale *scale;
-
+
gint tx, ty, twidth, theight;
-
+
g_return_if_fail (vscale != NULL);
g_return_if_fail (GTK_IS_VSCALE (vscale));
g_return_if_fail ((x != NULL) && (y != NULL) && (w != NULL) && (h != NULL));
-
+
gtk_vscale_pos_trough (vscale, &tx, &ty, &twidth, &theight);
widget = GTK_WIDGET (vscale);
scale = GTK_SCALE (vscale);
-
+
*x = widget->allocation.x;
*y = widget->allocation.y;
*w = widget->allocation.width;
*h = widget->allocation.height;
-
+
switch (scale->value_pos)
{
case GTK_POS_LEFT:
gtk_vscale_draw_slider (GtkRange *range)
{
GtkStateType state_type;
-
+
g_return_if_fail (range != NULL);
g_return_if_fail (GTK_IS_VSCALE (range));
-
+
if (range->slider)
{
if ((range->in_child == RANGE_CLASS (range)->slider) ||
state_type = GTK_STATE_PRELIGHT;
else
state_type = GTK_STATE_NORMAL;
-
- gtk_paint_slider(GTK_WIDGET (range)->style, range->slider, state_type,
+
+ gtk_paint_slider (GTK_WIDGET (range)->style, range->slider, state_type,
GTK_SHADOW_OUT,
NULL, GTK_WIDGET (range), "vscale",
0, 0, -1, -1,
gint text_width;
gint width, height;
gint x, y;
-
+
g_return_if_fail (scale != NULL);
g_return_if_fail (GTK_IS_VSCALE (scale));
-
+
widget = GTK_WIDGET (scale);
if (scale->draw_value)
{
sprintf (buffer, "%0.*f", GTK_RANGE (scale)->digits, GTK_RANGE (scale)->adjustment->value);
text_width = gdk_string_measure (GTK_WIDGET (scale)->style->font, buffer);
-
+
switch (scale->value_pos)
- {
- case GTK_POS_LEFT:
- gdk_window_get_position (GTK_RANGE (scale)->trough, &x, NULL);
- gdk_window_get_position (GTK_RANGE (scale)->slider, NULL, &y);
- gdk_window_get_size (GTK_RANGE (scale)->trough, &width, NULL);
- gdk_window_get_size (GTK_RANGE (scale)->slider, NULL, &height);
-
- x -= SCALE_CLASS (scale)->value_spacing + text_width;
- y += widget->allocation.y + ((height -
- (GTK_WIDGET (scale)->style->font->ascent +
- GTK_WIDGET (scale)->style->font->descent)) / 2 +
- GTK_WIDGET (scale)->style->font->ascent);
- break;
- case GTK_POS_RIGHT:
- gdk_window_get_position (GTK_RANGE (scale)->trough, &x, NULL);
- gdk_window_get_position (GTK_RANGE (scale)->slider, NULL, &y);
- gdk_window_get_size (GTK_RANGE (scale)->trough, &width, NULL);
- gdk_window_get_size (GTK_RANGE (scale)->slider, NULL, &height);
-
- x += width + SCALE_CLASS (scale)->value_spacing;
- y += widget->allocation.y + ((height -
- (GTK_WIDGET (scale)->style->font->ascent +
- GTK_WIDGET (scale)->style->font->descent)) / 2 +
- GTK_WIDGET (scale)->style->font->ascent);
- break;
- case GTK_POS_TOP:
- gdk_window_get_position (GTK_RANGE (scale)->trough, &x, &y);
- gdk_window_get_size (GTK_RANGE (scale)->slider, &width, NULL);
- gdk_window_get_size (GTK_RANGE (scale)->trough, NULL, &height);
-
- x += (width - text_width) / 2;
- y -= GTK_WIDGET (scale)->style->font->descent;
- break;
- case GTK_POS_BOTTOM:
- gdk_window_get_position (GTK_RANGE (scale)->trough, &x, &y);
- gdk_window_get_size (GTK_RANGE (scale)->slider, &width, NULL);
- gdk_window_get_size (GTK_RANGE (scale)->trough, NULL, &height);
-
- x += (width - text_width) / 2;
- y += height + GTK_WIDGET (scale)->style->font->ascent;
- break;
- }
-
+ {
+ case GTK_POS_LEFT:
+ gdk_window_get_position (GTK_RANGE (scale)->trough, &x, NULL);
+ gdk_window_get_position (GTK_RANGE (scale)->slider, NULL, &y);
+ gdk_window_get_size (GTK_RANGE (scale)->trough, &width, NULL);
+ gdk_window_get_size (GTK_RANGE (scale)->slider, NULL, &height);
+
+ x -= SCALE_CLASS (scale)->value_spacing + text_width;
+ y += widget->allocation.y + ((height -
+ (GTK_WIDGET (scale)->style->font->ascent +
+ GTK_WIDGET (scale)->style->font->descent)) / 2 +
+ GTK_WIDGET (scale)->style->font->ascent);
+ break;
+ case GTK_POS_RIGHT:
+ gdk_window_get_position (GTK_RANGE (scale)->trough, &x, NULL);
+ gdk_window_get_position (GTK_RANGE (scale)->slider, NULL, &y);
+ gdk_window_get_size (GTK_RANGE (scale)->trough, &width, NULL);
+ gdk_window_get_size (GTK_RANGE (scale)->slider, NULL, &height);
+
+ x += width + SCALE_CLASS (scale)->value_spacing;
+ y += widget->allocation.y + ((height -
+ (GTK_WIDGET (scale)->style->font->ascent +
+ GTK_WIDGET (scale)->style->font->descent)) / 2 +
+ GTK_WIDGET (scale)->style->font->ascent);
+ break;
+ case GTK_POS_TOP:
+ gdk_window_get_position (GTK_RANGE (scale)->trough, &x, &y);
+ gdk_window_get_size (GTK_RANGE (scale)->slider, &width, NULL);
+ gdk_window_get_size (GTK_RANGE (scale)->trough, NULL, &height);
+
+ x += (width - text_width) / 2;
+ y -= GTK_WIDGET (scale)->style->font->descent;
+ break;
+ case GTK_POS_BOTTOM:
+ gdk_window_get_position (GTK_RANGE (scale)->trough, &x, &y);
+ gdk_window_get_size (GTK_RANGE (scale)->slider, &width, NULL);
+ gdk_window_get_size (GTK_RANGE (scale)->trough, NULL, &height);
+
+ x += (width - text_width) / 2;
+ y += height + GTK_WIDGET (scale)->style->font->ascent;
+ break;
+ }
+
state_type = GTK_STATE_NORMAL;
if (!GTK_WIDGET_IS_SENSITIVE (scale))
- state_type = GTK_STATE_INSENSITIVE;
-
+ state_type = GTK_STATE_INSENSITIVE;
+
gtk_paint_string (GTK_WIDGET (scale)->style,
- GTK_WIDGET (scale)->window,
- state_type,
- NULL, GTK_WIDGET (scale), "vscale",
- x, y, buffer);
+ GTK_WIDGET (scale)->window,
+ state_type,
+ NULL, GTK_WIDGET (scale), "vscale",
+ x, y, buffer);
}
}
static gint
-gtk_vscale_trough_keys(GtkRange *range,
- GdkEventKey *key,
- GtkScrollType *scroll,
- GtkTroughType *pos)
+gtk_vscale_trough_keys (GtkRange *range,
+ GdkEventKey *key,
+ GtkScrollType *scroll,
+ GtkTroughType *pos)
{
gint return_val = FALSE;
switch (key->keyval)
#endif /* __cplusplus */
-#define GTK_VSCALE(obj) GTK_CHECK_CAST (obj, gtk_vscale_get_type (), GtkVScale)
-#define GTK_VSCALE_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_vscale_get_type (), GtkVScaleClass)
-#define GTK_IS_VSCALE(obj) GTK_CHECK_TYPE (obj, gtk_vscale_get_type ())
+#define GTK_TYPE_VSCALE (gtk_vscale_get_type ())
+#define GTK_VSCALE(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_VSCALE, GtkVScale))
+#define GTK_VSCALE_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_VSCALE, GtkVScaleClass))
+#define GTK_IS_VSCALE(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_VSCALE))
+#define GTK_IS_VSCALE_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_VSCALE))
typedef struct _GtkVScale GtkVScale;
};
-guint gtk_vscale_get_type (void);
+GtkType gtk_vscale_get_type (void);
GtkWidget* gtk_vscale_new (GtkAdjustment *adjustment);
#define RANGE_CLASS(w) GTK_RANGE_CLASS (GTK_OBJECT (w)->klass)
+enum {
+ ARG_0,
+ ARG_ADJUSTMENT,
+};
static void gtk_vscrollbar_class_init (GtkVScrollbarClass *klass);
static void gtk_vscrollbar_init (GtkVScrollbar *vscrollbar);
+static void gtk_vscrollbar_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
+static void gtk_vscrollbar_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
static void gtk_vscrollbar_realize (GtkWidget *widget);
static void gtk_vscrollbar_size_allocate (GtkWidget *widget,
- GtkAllocation *allocation);
+ GtkAllocation *allocation);
static void gtk_vscrollbar_draw_step_forw (GtkRange *range);
static void gtk_vscrollbar_draw_step_back (GtkRange *range);
static void gtk_vscrollbar_slider_update (GtkRange *range);
static void gtk_vscrollbar_calc_slider_size (GtkVScrollbar *vscrollbar);
static gint gtk_vscrollbar_trough_keys (GtkRange *range,
- GdkEventKey *key,
- GtkScrollType *scroll,
- GtkTroughType *pos);
+ GdkEventKey *key,
+ GtkScrollType *scroll,
+ GtkTroughType *pos);
-guint
+
+GtkType
gtk_vscrollbar_get_type (void)
{
- static guint vscrollbar_type = 0;
-
+ static GtkType vscrollbar_type = 0;
+
if (!vscrollbar_type)
{
GtkTypeInfo vscrollbar_info =
{
- "GtkVScrollbar",
- sizeof (GtkVScrollbar),
- sizeof (GtkVScrollbarClass),
- (GtkClassInitFunc) gtk_vscrollbar_class_init,
- (GtkObjectInitFunc) gtk_vscrollbar_init,
- /* reserved_1 */ NULL,
+ "GtkVScrollbar",
+ sizeof (GtkVScrollbar),
+ sizeof (GtkVScrollbarClass),
+ (GtkClassInitFunc) gtk_vscrollbar_class_init,
+ (GtkObjectInitFunc) gtk_vscrollbar_init,
+ /* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
};
-
- vscrollbar_type = gtk_type_unique (gtk_scrollbar_get_type (), &vscrollbar_info);
+
+ vscrollbar_type = gtk_type_unique (GTK_TYPE_SCROLLBAR, &vscrollbar_info);
}
-
+
return vscrollbar_type;
}
static void
-gtk_vscrollbar_class_init (GtkVScrollbarClass *klass)
+gtk_vscrollbar_class_init (GtkVScrollbarClass *class)
{
+ GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
GtkRangeClass *range_class;
-
- widget_class = (GtkWidgetClass*) klass;
- range_class = (GtkRangeClass*) klass;
-
+
+ object_class = (GtkObjectClass*) class;
+ widget_class = (GtkWidgetClass*) class;
+ range_class = (GtkRangeClass*) class;
+
+ gtk_object_add_arg_type ("GtkVScrollbar::adjustment",
+ GTK_TYPE_ADJUSTMENT,
+ GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
+ ARG_ADJUSTMENT);
+
+ object_class->set_arg = gtk_vscrollbar_set_arg;
+ object_class->get_arg = gtk_vscrollbar_get_arg;
+
widget_class->realize = gtk_vscrollbar_realize;
widget_class->size_allocate = gtk_vscrollbar_size_allocate;
-
+
range_class->draw_step_forw = gtk_vscrollbar_draw_step_forw;
range_class->draw_step_back = gtk_vscrollbar_draw_step_back;
range_class->slider_update = gtk_vscrollbar_slider_update;
range_class->motion = gtk_range_default_vmotion;
}
+static void
+gtk_vscrollbar_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkVScrollbar *vscrollbar;
+
+ vscrollbar = GTK_VSCROLLBAR (object);
+
+ switch (arg_id)
+ {
+ case ARG_ADJUSTMENT:
+ gtk_range_set_adjustment (GTK_RANGE (vscrollbar), GTK_VALUE_POINTER (*arg));
+ break;
+ default:
+ break;
+ }
+}
+
+static void
+gtk_vscrollbar_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkVScrollbar *vscrollbar;
+
+ vscrollbar = GTK_VSCROLLBAR (object);
+
+ switch (arg_id)
+ {
+ case ARG_ADJUSTMENT:
+ GTK_VALUE_POINTER (*arg) = GTK_RANGE (vscrollbar);
+ break;
+ default:
+ arg->type = GTK_TYPE_INVALID;
+ break;
+ }
+}
+
static void
gtk_vscrollbar_init (GtkVScrollbar *vscrollbar)
{
GtkWidget *widget;
GtkRequisition *requisition;
-
+
widget = GTK_WIDGET (vscrollbar);
requisition = &widget->requisition;
-
+
requisition->width = (RANGE_CLASS (widget)->slider_width +
- widget->style->klass->xthickness * 2);
+ widget->style->klass->xthickness * 2);
requisition->height = (RANGE_CLASS (widget)->min_slider_size +
- RANGE_CLASS (widget)->stepper_size +
- RANGE_CLASS (widget)->stepper_slider_spacing +
- widget->style->klass->ythickness) * 2;
+ RANGE_CLASS (widget)->stepper_size +
+ RANGE_CLASS (widget)->stepper_slider_spacing +
+ widget->style->klass->ythickness) * 2;
}
GtkWidget*
gtk_vscrollbar_new (GtkAdjustment *adjustment)
{
- GtkVScrollbar *vscrollbar;
-
- vscrollbar = gtk_type_new (gtk_vscrollbar_get_type ());
-
- if (!adjustment)
- adjustment = (GtkAdjustment*) gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
-
- gtk_range_set_adjustment (GTK_RANGE (vscrollbar), adjustment);
-
- return GTK_WIDGET (vscrollbar);
+ GtkWidget *vscrollbar;
+
+ vscrollbar = gtk_widget_new (GTK_TYPE_VSCROLLBAR,
+ "adjustment", adjustment,
+ NULL);
+
+ return vscrollbar;
}
GtkRange *range;
GdkWindowAttr attributes;
gint attributes_mask;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_VSCROLLBAR (widget));
-
+
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
range = GTK_RANGE (widget);
-
+
attributes.x = widget->allocation.x + (widget->allocation.width - widget->requisition.width) / 2;
attributes.y = widget->allocation.y;
attributes.width = widget->requisition.width;
attributes.colormap = gtk_widget_get_colormap (widget);
attributes.event_mask = gtk_widget_get_events (widget);
attributes.event_mask |= (GDK_EXPOSURE_MASK |
- GDK_BUTTON_PRESS_MASK |
- GDK_BUTTON_RELEASE_MASK |
- GDK_ENTER_NOTIFY_MASK |
- GDK_LEAVE_NOTIFY_MASK);
-
+ GDK_BUTTON_PRESS_MASK |
+ GDK_BUTTON_RELEASE_MASK |
+ GDK_ENTER_NOTIFY_MASK |
+ GDK_LEAVE_NOTIFY_MASK);
+
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
-
+
range->trough = widget->window;
gdk_window_ref (range->trough);
-
+
attributes.x = widget->style->klass->xthickness;
attributes.y = widget->style->klass->ythickness;
attributes.width = RANGE_CLASS (widget)->stepper_size;
attributes.height = RANGE_CLASS (widget)->stepper_size;
-
+
range->step_back = gdk_window_new (range->trough, &attributes, attributes_mask);
-
+
attributes.y = (widget->allocation.height -
- widget->style->klass->ythickness -
- RANGE_CLASS (widget)->stepper_size);
-
+ widget->style->klass->ythickness -
+ RANGE_CLASS (widget)->stepper_size);
+
range->step_forw = gdk_window_new (range->trough, &attributes, attributes_mask);
-
+
attributes.x = widget->style->klass->ythickness;
attributes.y = 0;
attributes.width = RANGE_CLASS (widget)->slider_width;
attributes.height = RANGE_CLASS (widget)->min_slider_size;
attributes.event_mask |= (GDK_BUTTON_MOTION_MASK |
- GDK_POINTER_MOTION_HINT_MASK);
-
+ GDK_POINTER_MOTION_HINT_MASK);
+
range->slider = gdk_window_new (range->trough, &attributes, attributes_mask);
-
+
gtk_vscrollbar_calc_slider_size (GTK_VSCROLLBAR (widget));
gtk_range_slider_update (GTK_RANGE (widget));
-
+
widget->style = gtk_style_attach (widget->style, widget->window);
-
+
gdk_window_set_user_data (range->trough, widget);
gdk_window_set_user_data (range->slider, widget);
gdk_window_set_user_data (range->step_forw, widget);
gdk_window_set_user_data (range->step_back, widget);
-
+
gtk_style_set_background (widget->style, range->trough, GTK_STATE_ACTIVE);
gtk_style_set_background (widget->style, range->slider, GTK_STATE_NORMAL);
gtk_style_set_background (widget->style, range->step_forw, GTK_STATE_ACTIVE);
gtk_style_set_background (widget->style, range->step_back, GTK_STATE_ACTIVE);
-
+
gdk_window_show (range->slider);
gdk_window_show (range->step_forw);
gdk_window_show (range->step_back);
static void
gtk_vscrollbar_size_allocate (GtkWidget *widget,
- GtkAllocation *allocation)
+ GtkAllocation *allocation)
{
GtkRange *range;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_VSCROLLBAR (widget));
g_return_if_fail (allocation != NULL);
-
+
widget->allocation = *allocation;
if (GTK_WIDGET_REALIZED (widget))
{
range = GTK_RANGE (widget);
-
+
gdk_window_move_resize (range->trough,
- allocation->x + (allocation->width - widget->requisition.width) / 2,
- allocation->y,
- widget->requisition.width, allocation->height);
+ allocation->x + (allocation->width - widget->requisition.width) / 2,
+ allocation->y,
+ widget->requisition.width, allocation->height);
gdk_window_move_resize (range->step_back,
- widget->style->klass->xthickness,
- widget->style->klass->ythickness,
- widget->requisition.width - widget->style->klass->xthickness * 2,
- RANGE_CLASS (widget)->stepper_size);
+ widget->style->klass->xthickness,
+ widget->style->klass->ythickness,
+ widget->requisition.width - widget->style->klass->xthickness * 2,
+ RANGE_CLASS (widget)->stepper_size);
gdk_window_move_resize (range->step_forw,
- widget->style->klass->xthickness,
- allocation->height - widget->style->klass->ythickness -
- RANGE_CLASS (widget)->stepper_size,
- widget->requisition.width - widget->style->klass->xthickness * 2,
- RANGE_CLASS (widget)->stepper_size);
+ widget->style->klass->xthickness,
+ allocation->height - widget->style->klass->ythickness -
+ RANGE_CLASS (widget)->stepper_size,
+ widget->requisition.width - widget->style->klass->xthickness * 2,
+ RANGE_CLASS (widget)->stepper_size);
gdk_window_resize (range->slider,
- widget->requisition.width - widget->style->klass->xthickness * 2,
- RANGE_CLASS (range)->min_slider_size);
-
+ widget->requisition.width - widget->style->klass->xthickness * 2,
+ RANGE_CLASS (range)->min_slider_size);
+
gtk_range_slider_update (GTK_RANGE (widget));
}
}
{
GtkStateType state_type;
GtkShadowType shadow_type;
-
+
g_return_if_fail (range != NULL);
g_return_if_fail (GTK_IS_VSCROLLBAR (range));
-
+
if (GTK_WIDGET_DRAWABLE (range))
{
if (range->in_child == RANGE_CLASS (range)->step_forw)
- {
- if (range->click_child == RANGE_CLASS (range)->step_forw)
- state_type = GTK_STATE_ACTIVE;
- else
- state_type = GTK_STATE_PRELIGHT;
- }
+ {
+ if (range->click_child == RANGE_CLASS (range)->step_forw)
+ state_type = GTK_STATE_ACTIVE;
+ else
+ state_type = GTK_STATE_PRELIGHT;
+ }
else
- state_type = GTK_STATE_NORMAL;
-
+ state_type = GTK_STATE_NORMAL;
+
if (range->click_child == RANGE_CLASS (range)->step_forw)
- shadow_type = GTK_SHADOW_IN;
+ shadow_type = GTK_SHADOW_IN;
else
- shadow_type = GTK_SHADOW_OUT;
-
+ shadow_type = GTK_SHADOW_OUT;
+
gtk_paint_arrow (GTK_WIDGET (range)->style, range->step_forw,
- state_type, shadow_type,
- NULL, GTK_WIDGET (range), "scrollbar",
- GTK_ARROW_DOWN,
- TRUE, 0, 0, -1, -1);
+ state_type, shadow_type,
+ NULL, GTK_WIDGET (range), "vscrollbar",
+ GTK_ARROW_DOWN,
+ TRUE, 0, 0, -1, -1);
}
}
{
GtkStateType state_type;
GtkShadowType shadow_type;
-
+
g_return_if_fail (range != NULL);
g_return_if_fail (GTK_IS_VSCROLLBAR (range));
-
+
if (GTK_WIDGET_DRAWABLE (range))
{
if (range->in_child == RANGE_CLASS (range)->step_back)
- {
- if (range->click_child == RANGE_CLASS (range)->step_back)
- state_type = GTK_STATE_ACTIVE;
- else
- state_type = GTK_STATE_PRELIGHT;
- }
+ {
+ if (range->click_child == RANGE_CLASS (range)->step_back)
+ state_type = GTK_STATE_ACTIVE;
+ else
+ state_type = GTK_STATE_PRELIGHT;
+ }
else
- state_type = GTK_STATE_NORMAL;
-
+ state_type = GTK_STATE_NORMAL;
+
if (range->click_child == RANGE_CLASS (range)->step_back)
- shadow_type = GTK_SHADOW_IN;
+ shadow_type = GTK_SHADOW_IN;
else
- shadow_type = GTK_SHADOW_OUT;
-
+ shadow_type = GTK_SHADOW_OUT;
+
gtk_paint_arrow (GTK_WIDGET (range)->style, range->step_back,
- state_type, shadow_type,
- NULL, GTK_WIDGET (range), "scrollbar",
- GTK_ARROW_UP,
- TRUE, 0, 0, -1, -1);
+ state_type, shadow_type,
+ NULL, GTK_WIDGET (range), "vscrollbar",
+ GTK_ARROW_UP,
+ TRUE, 0, 0, -1, -1);
}
}
{
g_return_if_fail (range != NULL);
g_return_if_fail (GTK_IS_VSCROLLBAR (range));
-
+
gtk_vscrollbar_calc_slider_size (GTK_VSCROLLBAR (range));
gtk_range_default_vslider_update (range);
}
gint slider_height;
gint top, bottom;
gint height;
-
+
g_return_if_fail (vscrollbar != NULL);
g_return_if_fail (GTK_IS_VSCROLLBAR (vscrollbar));
-
+
if (GTK_WIDGET_REALIZED (vscrollbar))
{
range = GTK_RANGE (vscrollbar);
-
+
gdk_window_get_size (range->step_back, NULL, &step_back_height);
gdk_window_get_position (range->step_back, NULL, &step_back_y);
gdk_window_get_position (range->step_forw, NULL, &step_forw_y);
-
+
top = (step_back_y +
- step_back_height +
- RANGE_CLASS (vscrollbar)->stepper_slider_spacing);
+ step_back_height +
+ RANGE_CLASS (vscrollbar)->stepper_slider_spacing);
bottom = step_forw_y - RANGE_CLASS (vscrollbar)->stepper_slider_spacing;
height = bottom - top;
-
+
if ((range->adjustment->page_size > 0) &&
- (range->adjustment->lower != range->adjustment->upper))
- {
- if (range->adjustment->page_size >
- (range->adjustment->upper - range->adjustment->lower))
- range->adjustment->page_size = range->adjustment->upper - range->adjustment->lower;
-
- height = (height * range->adjustment->page_size /
- (range->adjustment->upper - range->adjustment->lower));
-
- if (height < RANGE_CLASS (vscrollbar)->min_slider_size)
- height = RANGE_CLASS (vscrollbar)->min_slider_size;
- }
-
+ (range->adjustment->lower != range->adjustment->upper))
+ {
+ if (range->adjustment->page_size >
+ (range->adjustment->upper - range->adjustment->lower))
+ range->adjustment->page_size = range->adjustment->upper - range->adjustment->lower;
+
+ height = (height * range->adjustment->page_size /
+ (range->adjustment->upper - range->adjustment->lower));
+
+ if (height < RANGE_CLASS (vscrollbar)->min_slider_size)
+ height = RANGE_CLASS (vscrollbar)->min_slider_size;
+ }
+
gdk_window_get_size (range->slider, &slider_width, &slider_height);
-
+
if (slider_height != height)
- gdk_window_resize (range->slider, slider_width, height);
+ gdk_window_resize (range->slider, slider_width, height);
}
}
static gint
gtk_vscrollbar_trough_keys(GtkRange *range,
- GdkEventKey *key,
- GtkScrollType *scroll,
- GtkTroughType *pos)
+ GdkEventKey *key,
+ GtkScrollType *scroll,
+ GtkTroughType *pos)
{
gint return_val = FALSE;
switch (key->keyval)
case GDK_Page_Up:
return_val = TRUE;
if (key->state & GDK_CONTROL_MASK)
- *pos = GTK_TROUGH_START;
+ *pos = GTK_TROUGH_START;
else
- *scroll = GTK_SCROLL_PAGE_BACKWARD;
+ *scroll = GTK_SCROLL_PAGE_BACKWARD;
break;
case GDK_Page_Down:
return_val = TRUE;
if (key->state & GDK_CONTROL_MASK)
- *pos = GTK_TROUGH_END;
+ *pos = GTK_TROUGH_END;
else
- *scroll = GTK_SCROLL_PAGE_FORWARD;
+ *scroll = GTK_SCROLL_PAGE_FORWARD;
break;
}
return return_val;
#include <gtk/gtkscrollbar.h>
-#define GTK_VSCROLLBAR(obj) GTK_CHECK_CAST (obj, gtk_vscrollbar_get_type (), GtkVScrollbar)
-#define GTK_VSCROLLBAR_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_vscrollbar_get_type (), GtkVScrollbarClass)
-#define GTK_IS_VSCROLLBAR(obj) GTK_CHECK_TYPE (obj, gtk_vscrollbar_get_type ())
+#define GTK_TYPE_VSCROLLBAR (gtk_vscrollbar_get_type ())
+#define GTK_VSCROLLBAR(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_VSCROLLBAR, GtkVScrollbar))
+#define GTK_VSCROLLBAR_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_VSCROLLBAR, GtkVScrollbarClass))
+#define GTK_IS_VSCROLLBAR(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_VSCROLLBAR))
+#define GTK_IS_VSCROLLBAR_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_VSCROLLBAR))
typedef struct _GtkVScrollbar GtkVScrollbar;
#endif /* __cplusplus */
-guint gtk_vscrollbar_get_type (void);
+GtkType gtk_vscrollbar_get_type (void);
GtkWidget* gtk_vscrollbar_new (GtkAdjustment *adjustment);
object_class->finalize = gtk_widget_finalize;
klass->activate_signal = 0;
+ klass->scroll_adjustments_signal = 0;
klass->show = gtk_widget_real_show;
klass->show_all = gtk_widget_show;
klass->hide = gtk_widget_real_hide;
gtk_args_collect_cleanup (arg_list, info_list);
}
+ if (!GTK_OBJECT_CONSTRUCTED (object))
+ gtk_object_default_construct (object);
+
return GTK_WIDGET (object);
}
guint nargs,
GtkArg *args)
{
- g_return_val_if_fail (gtk_type_is_a (type, gtk_widget_get_type ()), NULL);
+ g_return_val_if_fail (gtk_type_is_a (type, GTK_TYPE_WIDGET), NULL);
return GTK_WIDGET (gtk_object_newv (type, nargs, args));
}
{
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
-
+ g_return_if_fail (GTK_OBJECT_CONSTRUCTED (widget));
+
gtk_object_destroy ((GtkObject*) widget);
}
* results:
*****************************************/
-void
+gboolean
gtk_widget_activate (GtkWidget *widget)
{
- g_return_if_fail (widget != NULL);
- g_return_if_fail (GTK_IS_WIDGET (widget));
+ g_return_val_if_fail (widget != NULL, FALSE);
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
if (WIDGET_CLASS (widget)->activate_signal)
- gtk_signal_emit (GTK_OBJECT (widget), WIDGET_CLASS (widget)->activate_signal);
+ {
+ /* FIXME: we should eventually check the signals signature here */
+ gtk_signal_emit (GTK_OBJECT (widget), WIDGET_CLASS (widget)->activate_signal);
+
+ return TRUE;
+ }
+ else
+ return FALSE;
+}
+
+gboolean
+gtk_widget_scroll_adjustements (GtkWidget *widget,
+ GtkAdjustment *hadjustment,
+ GtkAdjustment *vadjustment)
+{
+ g_return_val_if_fail (widget != NULL, FALSE);
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
+ if (hadjustment)
+ g_return_val_if_fail (GTK_IS_ADJUSTMENT (hadjustment), FALSE);
+ if (vadjustment)
+ g_return_val_if_fail (GTK_IS_ADJUSTMENT (vadjustment), FALSE);
+
+ if (WIDGET_CLASS (widget)->scroll_adjustments_signal)
+ {
+ /* FIXME: we should eventually check the signals signature here */
+ gtk_signal_emit (GTK_OBJECT (widget),
+ WIDGET_CLASS (widget)->scroll_adjustments_signal,
+ hadjustment, vadjustment);
+ return TRUE;
+ }
+ else
+ return FALSE;
}
/*****************************************
return return_val;
}
-
-gint
-gtk_widget_basic (GtkWidget *widget)
-{
- GList *children;
- GList *tmp_list;
- gint return_val;
-
- g_return_val_if_fail (widget != NULL, FALSE);
- g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
-
- if (!GTK_WIDGET_BASIC (widget))
- return FALSE;
- else if (GTK_IS_CONTAINER (widget))
- {
- children = gtk_container_children (GTK_CONTAINER (widget));
- if (children)
- {
- return_val = TRUE;
- tmp_list = children;
-
- while (tmp_list)
- {
- if (!gtk_widget_basic (GTK_WIDGET (tmp_list->data)))
- {
- return_val = FALSE;
- break;
- }
-
- tmp_list = tmp_list->next;
- }
-
- g_list_free (children);
- return return_val;
- }
- }
-
- return TRUE;
-}
-
-
/*****************************************
* gtk_widget_grab_focus:
*
}
void
-gtk_widget_push_composite (void)
+gtk_widget_push_composite_child (void)
{
composite_child_stack++;
}
void
-gtk_widget_pop_composite (void)
+gtk_widget_pop_composite_child (void)
{
if (composite_child_stack)
composite_child_stack--;
#include <gdk/gdk.h>
#include <gtk/gtkaccelgroup.h>
#include <gtk/gtkobject.h>
+#include <gtk/gtkadjustment.h>
#include <gtk/gtkstyle.h>
GTK_HAS_DEFAULT = 1 << 14,
GTK_HAS_GRAB = 1 << 15,
GTK_RC_STYLE = 1 << 16,
- GTK_COMPOSITE_CHILD = 1 << 17,
- GTK_BASIC = 1 << 18
+ GTK_COMPOSITE_CHILD = 1 << 17
} GtkWidgetFlags;
/* Macro for casting a pointer to a GtkWidget or GtkWidgetClass pointer.
#define GTK_WIDGET_HAS_GRAB(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_HAS_GRAB) != 0)
#define GTK_WIDGET_RC_STYLE(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_RC_STYLE) != 0)
#define GTK_WIDGET_COMPOSITE_CHILD(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_COMPOSITE_CHILD) != 0)
-#define GTK_WIDGET_BASIC(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_BASIC) != 0)
/* Macros for setting and clearing widget flags.
*/
*/
GtkObjectClass parent_class;
- /* The signal to emit when an object of this class is activated.
- * This is used when activating the current focus widget and
- * the default widget.
+ /* The signal to emit when a widget of this class is activated,
+ * gtk_widget_activate() handles the emission.
+ * Implementation of this signal is optional.
*/
guint activate_signal;
+
+ /* This signal is emitted when a widget of this class is added
+ * to a scrolling aware parent, gtk_widget_set_scroll_adjustments()
+ * handles the emission.
+ * Implementation of this signal is optional.
+ */
+ guint scroll_adjustments_signal;
/* basics */
void (* show) (GtkWidget *widget);
gint gtk_widget_event (GtkWidget *widget,
GdkEvent *event);
-void gtk_widget_activate (GtkWidget *widget);
+gboolean gtk_widget_activate (GtkWidget *widget);
+gboolean gtk_widget_scroll_adjustements (GtkWidget *widget,
+ GtkAdjustment *hadjustment,
+ GtkAdjustment *vadjustment);
+
void gtk_widget_reparent (GtkWidget *widget,
GtkWidget *new_parent);
void gtk_widget_popup (GtkWidget *widget,
gint gtk_widget_intersect (GtkWidget *widget,
GdkRectangle *area,
GdkRectangle *intersection);
-gint gtk_widget_basic (GtkWidget *widget);
void gtk_widget_grab_focus (GtkWidget *widget);
void gtk_widget_grab_default (GtkWidget *widget);
* This will override the values that got set by the
* gtk_widget_set_default_* () functions.
*/
-void gtk_widget_push_style (GtkStyle *style);
-void gtk_widget_push_colormap (GdkColormap *cmap);
-void gtk_widget_push_visual (GdkVisual *visual);
-void gtk_widget_push_composite_flag (void);
-void gtk_widget_pop_composite_flag (void);
-void gtk_widget_pop_style (void);
-void gtk_widget_pop_colormap (void);
-void gtk_widget_pop_visual (void);
+void gtk_widget_push_style (GtkStyle *style);
+void gtk_widget_push_colormap (GdkColormap *cmap);
+void gtk_widget_push_visual (GdkVisual *visual);
+void gtk_widget_push_composite_child (void);
+void gtk_widget_pop_composite_child (void);
+void gtk_widget_pop_style (void);
+void gtk_widget_pop_colormap (void);
+void gtk_widget_pop_visual (void);
/* Set certain default values to be used at widget creation time.
*/
(GtkSignalFunc)cb_tree_changed,
(gpointer)NULL);
gtk_object_set_user_data(GTK_OBJECT(root_tree), tree_buttons);
- gtk_container_add(GTK_CONTAINER(scrolled_win), root_tree);
+ gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), root_tree);
gtk_tree_set_selection_mode(GTK_TREE(root_tree), selection_mode);
gtk_tree_set_view_lines(GTK_TREE(root_tree), draw_line);
gtk_tree_set_view_mode(GTK_TREE(root_tree), !view_line);
table = gtk_table_new (20, 20, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 10);
gtk_table_set_col_spacings (GTK_TABLE (table), 10);
- gtk_container_add (GTK_CONTAINER (scrolled_window), table);
+ gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), table);
gtk_container_set_focus_hadjustment (GTK_CONTAINER (table),
gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
gtk_container_set_focus_vadjustment (GTK_CONTAINER (table),
list = gtk_list_new ();
gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_EXTENDED);
- gtk_container_add (GTK_CONTAINER (scrolled_win), list);
+ gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), list);
gtk_container_set_focus_vadjustment
(GTK_CONTAINER (list),
gtk_scrolled_window_get_vadjustment
gtk_widget_set_usize (scrolled_win, 100, 200);
list = gtk_list_new ();
- gtk_container_add (GTK_CONTAINER (scrolled_win), list);
+ gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), list);
gtk_signal_connect (GTK_OBJECT(list), "selection_received",
GTK_SIGNAL_FUNC (selection_test_received), NULL);
box2 = gtk_vbox_new (FALSE, 0);
gtk_container_border_width (GTK_CONTAINER (box2), 10);
- gtk_container_add (GTK_CONTAINER (scrolled_window), box2);
+ gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), box2);
gtk_container_set_focus_vadjustment (GTK_CONTAINER (box2),
gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
gtk_widget_show (box2);
(GtkSignalFunc)cb_tree_changed,
(gpointer)NULL);
gtk_object_set_user_data(GTK_OBJECT(root_tree), tree_buttons);
- gtk_container_add(GTK_CONTAINER(scrolled_win), root_tree);
+ gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), root_tree);
gtk_tree_set_selection_mode(GTK_TREE(root_tree), selection_mode);
gtk_tree_set_view_lines(GTK_TREE(root_tree), draw_line);
gtk_tree_set_view_mode(GTK_TREE(root_tree), !view_line);
table = gtk_table_new (20, 20, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 10);
gtk_table_set_col_spacings (GTK_TABLE (table), 10);
- gtk_container_add (GTK_CONTAINER (scrolled_window), table);
+ gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), table);
gtk_container_set_focus_hadjustment (GTK_CONTAINER (table),
gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
gtk_container_set_focus_vadjustment (GTK_CONTAINER (table),
list = gtk_list_new ();
gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_EXTENDED);
- gtk_container_add (GTK_CONTAINER (scrolled_win), list);
+ gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), list);
gtk_container_set_focus_vadjustment
(GTK_CONTAINER (list),
gtk_scrolled_window_get_vadjustment
gtk_widget_set_usize (scrolled_win, 100, 200);
list = gtk_list_new ();
- gtk_container_add (GTK_CONTAINER (scrolled_win), list);
+ gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), list);
gtk_signal_connect (GTK_OBJECT(list), "selection_received",
GTK_SIGNAL_FUNC (selection_test_received), NULL);
box2 = gtk_vbox_new (FALSE, 0);
gtk_container_border_width (GTK_CONTAINER (box2), 10);
- gtk_container_add (GTK_CONTAINER (scrolled_window), box2);
+ gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), box2);
gtk_container_set_focus_vadjustment (GTK_CONTAINER (box2),
gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
gtk_widget_show (box2);
projects / gtk4.git / commitdiff